diff --git a/.github/CODE_OF_CONDUCT.md b/.github/CODE_OF_CONDUCT.md new file mode 100644 index 00000000000..9875c90c1d3 --- /dev/null +++ b/.github/CODE_OF_CONDUCT.md @@ -0,0 +1,128 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our +community a harassment-free experience for everyone, regardless of age, body +size, visible or invisible disability, ethnicity, sex characteristics, gender +identity and expression, level of experience, education, socio-economic status, +nationality, personal appearance, race, religion, or sexual identity +and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, +diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the + overall community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or + advances of any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email + address, without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, threatening, offensive, +or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will communicate reasons for moderation +decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official e-mail address, +posting via an official social media account, or acting as an appointed +representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement at +DFINITY. +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series +of actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or +permanent ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within +the community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 2.0, available at +https://www.contributor-covenant.org/version/2/0/code_of_conduct.html. + +Community Impact Guidelines were inspired by [Mozilla's code of conduct +enforcement ladder](https://github.com/mozilla/diversity). + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see the FAQ at +https://www.contributor-covenant.org/faq. Translations are available at +https://www.contributor-covenant.org/translations. diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 00000000000..1f8b6390292 --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,111 @@ +# Contributing + +Thank you for your interest in contributing to this repo. +By participating in this project, you agree to abide by our [Code of Conduct](./CODE_OF_CONDUCT.md). + +As a member of the community, you are invited and encouraged to contribute by submitting issues, offering suggestions for improvements, adding review comments to existing pull requests, or creating new pull requests to fix issues. + +All contributions to DFINITY documentation and the developer community are respected and appreciated. +Your participation is an important factor in the success of the Internet Computer. + +## Contents of this repository + +This repository contains source code for the canister interface description language—often referred to as Candid or IDL. Candid provides a common language for specifying the signature of a canister service and interacting with canisters running on the +Internet Computer. + +## Before you contribute + +Before contributing, please take a few minutes to review these contributor guidelines. +The contributor guidelines are intended to make the contribution process easy and effective for everyone involved in addressing your issue, assessing changes, and finalizing your pull requests. + +Before contributing, consider the following: + +- If you want to report an issue, click **Issues**. + +- If you have more general questions related to Candid and its use, post a message to the [community forum](https://forum.dfinity.org/) or submit a [support request](mailto://support@dfinity.org). + +- If you are reporting a bug, provide as much information about the problem as possible. + +- If you want to contribute directly to this repository, typical fixes might include any of the following: + + - Fixes to resolve bugs or documentation errors + - Code improvements + - Feature requests + + Note that any contribution to this repository must be submitted in the form of a **pull request**. + +- If you are creating a pull request, be sure that the pull request only implements one fix or suggestion. + +If you are new to working with GitHub repositories and creating pull requests, consider exploring [First Contributions](https://github.com/firstcontributions/first-contributions) or [How to Contribute to an Open Source Project on GitHub](https://egghead.io/courses/how-to-contribute-to-an-open-source-project-on-github). + +# How to make a contribution + +Depending on the type of contribution you want to make, you might follow different workflows. + +This section describes the most common workflow scenarios: + +- Reporting an issue +- Submitting a pull request + +### Reporting an issue + +To open a new issue: + +1. Click **Issues**. + +1. Click **New Issue**. + +1. Click **Open a blank issue**. + +1. Type a title and description, then click **Submit new issue**. + + Be as clear and descriptive as possible. + + For any problem, describe it in detail, including details about the crate, the version of the code you are using, the results you expected, and how the actual results differed from your expectations. + +### Submitting a pull request + +If you want to submit a pull request to fix an issue or add a feature, here's a summary of what you need to do: + +1. Make sure you have a GitHub account, an internet connection, and access to a terminal shell or GitHub Desktop application for running commands. + +1. Navigate to the DFINITY public repository in a web browser. + +1. Click **Fork** to create a copy of the repository associated with the issue you want to address under your GitHub account or organization name. + +1. Clone the repository to your local machine. + +1. Create a new branch for your fix by running a command similar to the following: + + ```bash + git checkout -b my-branch-name-here + ``` + +1. Open the file you want to fix in a text editor and make the appropriate changes for the issue you are trying to address. + +1. Add the file contents of the changed files to the index `git` uses to manage the state of the project by running a command similar to the following: + + ```bash + git add path-to-changed-file + ``` +1. Commit your changes to store the contents you added to the index along with a descriptive message by running a command similar to the following: + + ```bash + git commit -m "Description of the fix being committed." + ``` + +1. Push the changes to the remote repository by running a command similar to the following: + + ```bash + git push origin my-branch-name-here + ``` + +1. Create a new pull request for the branch you pushed to the upstream GitHub repository. + + Provide a title that includes a short description of the changes made. + +1. Wait for the pull request to be reviewed. + +1. Make changes to the pull request, if requested. + +1. Celebrate your success after your pull request is merged! diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 00000000000..24fb13978cf --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,9 @@ +version: 2 +updates: + - package-ecosystem: github-actions + directory: "/" + schedule: + interval: daily + time: '00:00' + timezone: UTC + open-pull-requests-limit: 10 diff --git a/.github/workflows/comment-artifact-link.yml b/.github/workflows/comment-artifact-link.yml index 78217b23aee..3b91f725bb3 100644 --- a/.github/workflows/comment-artifact-link.yml +++ b/.github/workflows/comment-artifact-link.yml @@ -10,7 +10,7 @@ jobs: if: github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion == 'success' runs-on: ubuntu-latest steps: - - uses: actions/github-script@v6 + - uses: actions/github-script@v7 with: # This snippet is public-domain, taken from # https://github.com/oprypin/nightly.link/blob/master/.github/workflows/pr-comment.yml diff --git a/.github/workflows/niv-updater-rare.yml b/.github/workflows/niv-updater-rare.yml index 8b7e5d57b11..e65a823f045 100644 --- a/.github/workflows/niv-updater-rare.yml +++ b/.github/workflows/niv-updater-rare.yml @@ -11,7 +11,7 @@ on: types: niv-updater-nudge schedule: # * is a special character in YAML so you have to quote this string - # Run every monday + # Run every Monday - cron: '0 0 * * 1' jobs: niv-updater: @@ -20,10 +20,10 @@ jobs: runs-on: ubuntu-latest steps: - name: niv-updater-action - uses: knl/niv-updater-action@v12 + uses: knl/niv-updater-action@v15 with: # might be too noisy - whitelist: 'ic-ref,musl-wasi' + whitelist: 'ic-ref,ic-wasm' labels: | automerge-squash keep_updating: true diff --git a/.github/workflows/niv-updater-trial.yml b/.github/workflows/niv-updater-trial.yml index 36333ed12e2..e202c40c6ab 100644 --- a/.github/workflows/niv-updater-trial.yml +++ b/.github/workflows/niv-updater-trial.yml @@ -17,7 +17,7 @@ on: types: niv-updater-nudge schedule: # * is a special character in YAML so you have to quote this string - # Run every monday + # Run every Monday - cron: '0 0 * * 0' jobs: niv-updater: @@ -26,9 +26,9 @@ jobs: runs-on: ubuntu-latest steps: - name: niv-updater-action - uses: knl/niv-updater-action@v12 + uses: knl/niv-updater-action@v15 with: - whitelist: 'nixpkgs,musl-wasi,ic' + whitelist: 'nixpkgs,ic' labels: | autoclose keep_updating: true diff --git a/.github/workflows/niv-updater.yml b/.github/workflows/niv-updater.yml index e5cfc212bd8..31dc1e07a07 100644 --- a/.github/workflows/niv-updater.yml +++ b/.github/workflows/niv-updater.yml @@ -20,10 +20,10 @@ jobs: runs-on: ubuntu-latest steps: - name: niv-updater-action - uses: knl/niv-updater-action@v12 + uses: knl/niv-updater-action@v15 with: # might be too noisy - blacklist: 'nixpkgs,ic-ref,musl-wasi,ic' + blacklist: 'nixpkgs,ic-ref,ic' labels: | automerge-squash keep_updating: true diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index ae90f7492f4..8c25b61a57f 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -18,7 +18,7 @@ jobs: changelog: runs-on: 'ubuntu-latest' steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Get the version id: get_version @@ -43,20 +43,18 @@ jobs: build: strategy: matrix: - os: [ ubuntu-latest, macos-latest ] + os: [ ubuntu-latest, macos-13 ] needs: changelog runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v3 - - uses: cachix/install-nix-action@v20 - with: - install_url: https://releases.nixos.org/nix/nix-2.13.3/install - - uses: cachix/cachix-action@v12 + - uses: actions/checkout@v4 + - uses: cachix/install-nix-action@v30 + - uses: cachix/cachix-action@v15 if: startsWith(github.ref, 'refs/heads/') with: name: ic-hs-test # NB: No auth token, we don’t want to push new stuff here - - uses: cachix/cachix-action@v12 + - uses: cachix/cachix-action@v15 if: startsWith(github.ref, 'refs/tags/') with: name: ic-hs-test @@ -75,11 +73,9 @@ jobs: runs-on: 'ubuntu-latest' needs: [ changelog, build ] steps: - - uses: actions/checkout@v3 - - uses: cachix/install-nix-action@v20 - with: - install_url: https://releases.nixos.org/nix/nix-2.13.3/install - - uses: cachix/cachix-action@v12 + - uses: actions/checkout@v4 + - uses: cachix/install-nix-action@v30 + - uses: cachix/cachix-action@v15 with: name: ic-hs-test # NB: No auth token, we don’t expect to push new stuff here diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 6ff7fe08d13..5ea8aa48b27 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -7,33 +7,55 @@ jobs: tests: strategy: matrix: - os: [ ubuntu-latest, macos-latest ] + os: [ ubuntu-latest, macos-13 ] fail-fast: false runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: # fetch full history so that git merge-base works fetch-depth: 0 # fetch PR commit, not predicted merge commit ref: ${{ github.event.pull_request.head.sha }} - - uses: cachix/install-nix-action@v20 - with: - install_url: https://releases.nixos.org/nix/nix-2.13.3/install + - uses: cachix/install-nix-action@v30 # We are using the ic-hs-test cachix cache that is also used by # dfinity/ic-hs. This is partly laziness (on need to set up a separate # cache), but also to get the ic-ref-test binary without rebuilding - - uses: cachix/cachix-action@v12 + - uses: cachix/cachix-action@v15 with: name: ic-hs-test authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}' + # Free up disk space on Ubuntu + - name: Free Disk Space (Ubuntu) + uses: insightsengineering/disk-space-reclaimer@v1 + if: startsWith(matrix.os, 'ubuntu-') + with: + # this might remove tools that are actually needed, + # if set to "true" but frees about 6 GB + tools-cache: false + + # all of these default to true, but feel free to set to + # "false" if necessary for your workflow + android: true + dotnet: true + haskell: true + large-packages: true + docker-images: true + swap-storage: false + # until https://github.com/cachix/cachix-action/issues/86 is fixed: - run: cachix watch-store ic-hs-test & - run: nix-env -iA nix-build-uncached -f nix/ + - name: "pre-build `drun`" + if: startsWith(github.head_ref, 'update/ic-') + run: | + nix-build --max-jobs 1 -A drun + nix-store --gc --print-roots | grep /motoko/ + - name: "nix-build" run: nix-build-uncached --max-jobs 4 -A all-systems-go -build-flags -L @@ -57,7 +79,7 @@ jobs: - name: Find performance comment if: github.actor != 'dependabot[bot]' && runner.os == 'Linux' && github.event_name == 'pull_request' - uses: peter-evans/find-comment@v2 + uses: peter-evans/find-comment@v3 id: fc with: issue-number: ${{ github.event.pull_request.number }} @@ -68,7 +90,7 @@ jobs: # motoko#2864. - name: Create or update performance comment if: github.actor != 'dependabot[bot]' && runner.os == 'Linux' && github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository - uses: peter-evans/create-or-update-comment@v2 + uses: peter-evans/create-or-update-comment@v4 with: comment-id: ${{ steps.fc.outputs.comment-id }} issue-number: ${{ github.event.pull_request.number }} @@ -83,11 +105,9 @@ jobs: concurrency: ci-${{ github.ref }} runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 - - uses: cachix/install-nix-action@v20 - with: - install_url: https://releases.nixos.org/nix/nix-2.13.3/install - - uses: cachix/cachix-action@v12 + - uses: actions/checkout@v4 + - uses: cachix/install-nix-action@v30 + - uses: cachix/cachix-action@v15 with: name: ic-hs-test - name: Fetch report @@ -103,15 +123,14 @@ jobs: artifacts: if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository && contains(github.event.pull_request.labels.*.name, 'build_artifacts') - needs: tests - concurrency: ci-${{ github.ref }} - runs-on: ubuntu-latest + strategy: + matrix: + os: [ ubuntu-latest, macos-13 ] + runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v3 - - uses: cachix/install-nix-action@v20 - with: - install_url: https://releases.nixos.org/nix/nix-2.13.3/install - - uses: cachix/cachix-action@v12 + - uses: actions/checkout@v4 + - uses: cachix/install-nix-action@v30 + - uses: cachix/cachix-action@v15 with: name: ic-hs-test - name: nix-build @@ -121,9 +140,8 @@ jobs: # https://github.com/actions/upload-artifact/issues/92 - run: echo "UPLOAD_PATH=$(readlink -f result)" >> $GITHUB_ENV - name: upload artifacts - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: - name: moc + name: moc-${{ matrix.os }} path: ${{ env.UPLOAD_PATH }} retention-days: 5 - diff --git a/.github/workflows/update-hash.yml b/.github/workflows/update-hash.yml index f748aa60d5f..54cef9d8be1 100644 --- a/.github/workflows/update-hash.yml +++ b/.github/workflows/update-hash.yml @@ -12,15 +12,14 @@ jobs: if: github.actor != 'dependabot[bot]' runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: # This is needed to be able to push and trigger CI with that push token: ${{ secrets.NIV_UPDATER_TOKEN }} - - uses: cachix/install-nix-action@v20 + - uses: cachix/install-nix-action@v30 with: - install_url: https://releases.nixos.org/nix/nix-2.13.3/install nix_path: nixpkgs=channel:nixos-22.11 - - uses: cachix/cachix-action@v12 + - uses: cachix/cachix-action@v15 with: name: ic-hs-test authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}' @@ -28,8 +27,11 @@ jobs: run: | cd nix nix shell -f . nix-update -c nix-update --version=skip drun + - name: Update ic-wasm cargo hash + run: | + nix shell -f default.nix nix-update -c nix-update --version=skip ic-wasm - name: Commit changes - uses: EndBug/add-and-commit@v9.1.1 + uses: EndBug/add-and-commit@v9.1.4 with: default_author: github_actions author_name: Nix hash updater diff --git a/.mergify.yml b/.mergify.yml index ebaa0d6be30..877ca10d017 100644 --- a/.mergify.yml +++ b/.mergify.yml @@ -1,10 +1,23 @@ queue_rules: - name: default - conditions: + queue_conditions: + - "#approved-reviews-by>=1" + - "#changes-requested-reviews-by=0" + - status-success=tests (ubuntu-latest) + - status-success=tests (macos-13) + - base=master + - label=automerge-squash + merge_conditions: - "#approved-reviews-by>=1" - "#changes-requested-reviews-by=0" - status-success=tests (ubuntu-latest) - - status-success=tests (macos-latest) + - status-success=tests (macos-13) + merge_method: squash + commit_message_template: | + {{ title }} (#{{ number }}) + + {{ body }} + pull_request_rules: - name: Automatic merge (squash) @@ -12,22 +25,16 @@ pull_request_rules: - "#approved-reviews-by>=1" - "#changes-requested-reviews-by=0" - status-success=tests (ubuntu-latest) - - status-success=tests (macos-latest) + - status-success=tests (macos-13) - base=master - label=automerge-squash actions: - queue: - name: default - method: squash - commit_message_template: | - {{ title }} (#{{ number }}) - - {{ body }} delete_head_branch: {} + queue: - name: Automatically closing successful trials conditions: - status-success=tests (ubuntu-latest) - - status-success=tests (macos-latest) + - status-success=tests (macos-13) - label=autoclose actions: close: @@ -39,8 +46,8 @@ pull_request_rules: actions: label: remove: - - automerge-squash - - autoclose + - automerge-squash + - autoclose - name: Auto-approve auto-PRs conditions: - author=dfinity-bot @@ -70,4 +77,4 @@ pull_request_rules: message: A change to `doc/docusaurus/package-lock.json`? I can handle that! label: add: - - automerge-squash + - automerge-squash diff --git a/Building.md b/Building.md index 99c6cef29eb..f89b5389e6d 100644 --- a/Building.md +++ b/Building.md @@ -20,10 +20,11 @@ dependencies manually, which can take several hours. ## Installation using Nix If you want just to _use_ `moc`, you can install the `moc` binary into your `nix` -environment with +environment by running ``` $ nix-env -i -f . -A moc ``` +in a check-out of the `motoko` repository. ## Development using Nix @@ -55,11 +56,11 @@ For more details on our CI and CI setup, see `CI.md`. ## Making releases -We make frequent releases, at least weekly. The steps to make a release (say, version 0.9.1) are: +We make frequent releases, at least weekly. The steps to make a release (say, version 0.13.1) are: * Make sure that the top section of `Changelog.md` has a title like - ## 0.9.1 (2023-06-12) + ## 0.13.1 (2024-09-10) with today’s date. @@ -76,18 +77,18 @@ We make frequent releases, at least weekly. The steps to make a release (say, ve * Define a shell variable `export MOC_MINOR=1` - * Look at `git log --first-parent 0.9.$(expr $MOC_MINOR - 1)..HEAD` and check + * Look at `git log --first-parent 0.13.$(expr $MOC_MINOR - 1)..HEAD` and check that everything relevant is mentioned in the changelog section, and possibly clean it up a bit, curating the information for the target audience. - * `git commit -am "Releasing 0.8.$MOC_MINOR"` + * `git commit -am "chore: Releasing 0.13."$MOC_MINOR` * Create a PR from this commit, and label it `automerge-squash`. E.g. - with `git push origin HEAD:$USER/0.9.$MOC_MINOR`. Mergify will + with `git push origin HEAD:$USER/0.13.$MOC_MINOR`. Mergify will merge it into `master` without additional approval, but it will take some time as the title (version number) enters into the `nix` dependency tracking. * `git switch master; git pull --rebase`. The release commit should be your `HEAD` - * `git tag 0.9.$MOC_MINOR -m "Motoko 0.9.$MOC_MINOR"` - * `git push origin 0.9.$MOC_MINOR` + * `git tag 0.13.$MOC_MINOR -m "Motoko 0.13."$MOC_MINOR` + * `git push origin 0.13.$MOC_MINOR` Pushing the tag should cause GitHub Actions to create a “Release” on the GitHub project. This will fail if the changelog is not in order (in this case, fix and @@ -101,11 +102,13 @@ branch to the `next-moc` branch. * Wait ca. 5min after releasing to give the CI/CD pipeline time to upload the release artifacts * Change into `motoko-base` * `git switch next-moc; git pull` -* `git switch -c $USER/update-moc-0.9.$MOC_MINOR` -* Update the `moc_version` env variable in `.github/workflows/{ci, package-set}.yml` +* `git switch -c $USER/update-moc-0.13.$MOC_MINOR` +* Update the `CHANGELOG.md` file with an entry at the top +* Update the `moc_version` env variable in `.github/workflows/{ci, package-set}.yml` and `mops.toml` to the new released version: - `perl -pi -e "s/moc_version: \"0\.9\.\\d+\"/moc_version: \"0.9.$MOC_MINOR\"/g" .github/workflows/ci.yml .github/workflows/package-set.yml` -* `git add .github/ && git commit -m "Motoko 0.9.$MOC_MINOR"` + `perl -pi -e "s/moc_version: \"0\.13\.\\d+\"/moc_version: \"0.13.$MOC_MINOR\"/g; s/moc = \"0\.13\.\\d+\"/moc = \"0.13.$MOC_MINOR\"/g; s/version = \"0\.13\.\\d+\"/version = \"0.13.$MOC_MINOR\"/g" .github/workflows/ci.yml .github/workflows/package-set.yml mops.toml` +* `git add .github/ CHANGELOG.md mops.toml && git commit -m "Motoko 0.13."$MOC_MINOR` +* Revise `CHANGELOG.md`, adding a top entry for the release * You can `git push` now Make a PR off of that branch and merge it using a _normal merge_ (not @@ -114,25 +117,25 @@ repo by a scheduled `niv-updater-action`. Finally tag the base release (so the documentation interpreter can do the right thing): * `git switch master && git pull` -* `git tag moc-0.9.$MOC_MINOR` -* `git push origin moc-0.9.$MOC_MINOR` +* `git tag moc-0.13.$MOC_MINOR` +* `git push origin moc-0.13.$MOC_MINOR` If you want to update the portal documentation, typically to keep in sync with a `dfx` release, follow the instructions in https://github.com/dfinity/portal/blob/master/MAINTENANCE.md. ## Coverage report To build with coverage enabled, compile the binaries in `src/` with - - make DUNE_OPTS="--instrument-with bisect_ppx"` - +``` +make DUNE_OPTS="--instrument-with bisect_ppx"` +``` and then use `bisect-ppx-report html` to produce a report. The full report can be built with - - nix-build -A tests.coverage - +``` +nix-build -A tests.coverage +``` and the report for latest `master` can be viewed at -. +[https://dfinity.github.io/motoko/coverage/](https://dfinity.github.io/motoko/coverage/). ## Profile the compiler diff --git a/CI.md b/CI.md index 1d0b9b9375a..27fe264ac9e 100644 --- a/CI.md +++ b/CI.md @@ -114,7 +114,7 @@ Hydra job status page, and the there is a stable link for the latest build of **Implementation (external):** The latest `master` version of the file is availble at -. +[https://dfinity.github.io/motoko/](https://dfinity.github.io/motoko/). The reports are calculated in PRs (so failures would be caught), but are not hosted anywhere. diff --git a/Changelog.md b/Changelog.md index e7567a4edb5..2360ede6f57 100644 --- a/Changelog.md +++ b/Changelog.md @@ -1,5 +1,514 @@ # Motoko compiler changelog +## 0.13.4 (2024-11-29) + +* motoko (`moc`) + + * refactoring: Updating and simplifying the runtime system dependencies (#4677). + +* motoko-base + + * Breaking change (minor): `Float.format(#hex)` is no longer supported. + This is because newer versions of Motoko (such as with enhanced orthogonal persistence) + rely on the Rust-native formatter that does not offer this functionality. + It is expected that this formatter is very rarely used in practice (dfinity/motoko-base⁠#589). + + * Formatter change (minor): The text formatting of `NaN`, positive or negative, + will be `NaN` in newer Motoko versions, while it was `nan` or `-nan` in older versions (dfinity/motoko-base⁠#589). + +## 0.13.3 (2024-11-13) + +* motoko (`moc`) + + * typing: suggest conversions between primitive types from imported libraries + and, with `--ai-errors`, all available package libraries (#4747). + +* motoko-base + + * Add modules `OrderedMap` and `OrderedSet` to replace `RBTree` with improved functionality, performance + and ergonomics avoiding the need for preupgrade hooks (thanks to Serokell) (dfinity/motoko-base⁠#662). + +## 0.13.2 (2024-10-18) + +* motoko (`moc`) + + * Made the `actor`'s _self_ identifier available in the toplevel block. This also allows using + functions that refer to _self_ from the initialiser (e.g. calls to `setTimer`) (#4720). + + * bugfix: `actor ` now correctly performs definedness tracking (#4731). + +## 0.13.1 (2024-10-07) + +* motoko (`moc`) + + * Improved error messages for unbound identifiers and fields that avoid reporting large types and use an edit-distance based metric to suggest alternatives (#4720). + + * Flag `--ai-errors` to tailor error messages to AI clients (#4720). + + * Compilation units containing leading type definitions are now rejected with an improved error message (#4714). + + * bugfix: `floatToInt64` now behaves correctly in the interpreter too (#4712). + +## 0.13.0 (2024-09-17) + +* motoko (`moc`) + + * Added a new primitive `cyclesBurn : Nat -> Nat` for burning the canister's cycles + programmatically (#4690). + + * **For beta testing:** Support __enhanced orthogonal persistence__, enabled with new `moc` flag `--enhanced-orthogonal-persistence` (#4193). + + This implements scalable and efficient orthogonal persistence (stable variables) for Motoko: + * The Wasm main memory (heap) is retained on upgrade with new program versions directly picking up this state. + * The Wasm main memory has been extended to 64-bit to scale as large as stable memory in the future. + * The runtime system checks that data changes of new program versions are compatible with the old state. + + Implications: + * Upgrades become extremely fast, only depending on the number of types, not on the number of heap objects. + * Upgrades will no longer hit the IC instruction limit, even for maximum heap usage. + * The change to 64-bit increases the memory demand on the heap, in worst case by a factor of two. + * For step-wise release handling, the IC initially only offers a limited capacity of the 64-bit space (e.g. 4GB or 6GB), that will be gradually increased in future to the capacity of stable memory. + * There is moderate performance regression of around 10% for normal execution due to combined related features (precise tagging, change to incremental GC, and handling of compile-time-known data). + * The garbage collector is fixed to incremental GC and cannot be chosen. + * `Float.format(#hex prec, x)` is no longer supported (expected to be very rarely used in practice). + * The debug print format of `NaN` changes (originally `nan`). + + To activate enhanced orthogonal persistence under `dfx`, the following command-line argument needs to be specified in `dfx.json`: + + ``` + ... + "type" : "motoko" + ... + "args" : "--enhanced-orthogonal-persistence" + ... + ``` + BREAKING CHANGE (Minor): changes some aspects of `Float` formatting. + + For more information, see: + * The Motoko design documentation `design/OrthogonalPersistence.md` + * The Motoko user documentation `doc/md/canister-maintenance/upgrades.md`. + + * Candid decoding: impose an upper limit on the number of values decoded or skipped in a single candid payload, + as a linear function, `max_values`, of binary payload size. + + ``` + max_values(blob) = (blob.size() * numerator)/denominator + bias + ``` + + The current default settings are `{numerator = 1; denominator = 1; bias = 1024 }`, allowing a maximum + of 1024 values plus one additional value per byte in the payload. + + While hopefully not required, the constant factors can be read/modified using system functions: + * Prim.setCandidLimits: `{numerator : Nat32; denominator : Nat32; bias : Nat32 } -> ()` + * Prim.getCandidLimits: `() -> {numerator : Nat32; denominator : Nat32; bias : Nat32 }` + +## 0.12.1 (2024-08-08) + +* motoko (`moc`) + + * Added a new command-line flag `--print-source-on-error` to print source code context on error (#4650). + + * debugging: `__motoko_runtime_information()` as privileged query for runtime statistics (#4635). + + Exposing a privileged system-level query function `__motoko_runtime_information()` + that reports the current runtime statistics of the canister, such as the heap size, + the total number of allocated objects, the total amount of reclaimed memory and more. + This is useful because several statistics of the reported information cannot be + inspected on the IC replica dashboard as they are internal to the Motoko runtime system. + This query is only authorized to the canister controllers and self-calls of the canister. + + ``` Motoko + __motoko_runtime_information : () -> { + compilerVersion : Text; + rtsVersion : Text; + garbageCollector : Text; + sanityChecks : Nat; + memorySize : Nat; + heapSize : Nat; + totalAllocation : Nat; + reclaimed : Nat; + maxLiveSize : Nat; + stableMemorySize : Nat; + logicalStableMemorySize : Nat; + maxStackSize : Nat; + callbackTableCount : Nat; + callbackTableSize : Nat; + } + ``` + +* motoko-base + + * Added `Iter.concat` function (thanks to AndyGura) (dfinity/motoko-base⁠#650). + +## 0.12.0 (2024-07-26) + +* motoko (`moc`) + + * feat: `finally` clauses for `try` expressions (#4507). + + A trailing `finally` clause to `try`/`catch` expressions facilitates structured + resource deallocation (e.g. acquired locks, etc.) and similar cleanups in the + presence of control-flow expressions (`return`, `break`, `continue`, `throw`). + Additionally, in presence of `finally` the `catch` clause becomes optional and + and any uncaught error from the `try` block will be propagated, after executing the `finally` block. + + _Note_: `finally`-expressions that are in scope will be executed even if an execution + path _following_ an `await`-expression traps. This feature, formerly not available in Motoko, + allows programmers to implement cleanups even in the presence of traps. For trapping + execution paths prior to any `await`, the replica-provided state roll-back mechanism + ensures that no cleanup is required. + + The relevant security best practices are accessible at + https://internetcomputer.org/docs/current/developer-docs/security/security-best-practices/inter-canister-calls#recommendation + + BREAKING CHANGE (Minor): `finally` is now a reserved keyword, + programs using this identifier will break. + + * bugfix: `mo-doc` will now generate correct entries for `public` variables (#4626). + +## 0.11.3 (2024-07-16) + +* motoko (`moc`) + + * feat: `motoko-san` contributions by Serokell. Now able to verify some simple but non-trivial actors + (thanks to the entire Serokell team) (#4500). + + * bugfix: Corrects the interpreter (and compiler) to recognise certain type parameters as callable function types (#4617). + +## 0.11.2 (2024-07-06) + +* motoko (`moc`) + + * deprecation: Deprecate the use of base library's `ExperimentalStableMemory` (ESM) (#4573). + New `moc` flag `--experimental-stable-memory ` controls the level of deprecation: + * n < 0: error on use of stable memory primitives. + * n = 0: warn on use of stable memory primitives. + * n > 1: warning-less use of stable memory primitives (for legacy applications). + Users of ESM should consider migrating their code to use isolated regions (library `Region.mo`) instead. + + * bugfix: Fix the detection of unused declarations in `switch` and `catch` alternatives (#4560). + + * improvement: Only warn on unused identifiers if type checking is error-free (#4561). + +## 0.11.1 (2024-03-15) + +* motoko (`moc`) + + * feat: Custom error message for unused, punned field bindings (#4454). + + * feat: Don't report top-level identifiers as unused (#4452). + + * bugfix: Declaring `` capability on a class enables system capabilities in its body (#4449). + + * bugfix: Fix crash compiling actor reference containing an `await` (#4418, #4450). + + * bugfix: Fix crash when compiling with flag `--experimental-rtti` (#4434). + +## 0.11.0 (2024-03-05) + +* motoko (`moc`) + + * Warn on detection of unused identifiers (code `M0194`) (#4377). + + - By design, warnings are not emitted for code imported from a package. + - A warning can be suppressed by replacing the identifier entirely by a wildcard `_`, + or by prefixing it with an `_`, e.g. replace `x` by `_x`. + + **Limitations**: recursive and mutually recursive definitions are considered used, + even if never referenced outside the recursive definition. + + * Remove `__get_candid_interface_tmp_hack` endpoint. Candid interface is already stored as canister metadata, this temporary endpoint is redundant, thus removed. (#4386) + + * Improved capability system, introducing a synchronous (`system`) capability (#4406). + + `actor` initialisation body, `pre`/`postupgrade` hooks, `async` function bodies (and + blocks) possess this capability. Functions (and classes) can demand it by prepending `system` + to the type argument list. The capability can be forwarded in calls by mentioning `` + in the instantiation parameter list. + + BREAKING CHANGE (Minor): A few built-in functions have been marked with demand + for the `system` capability. In order to call these, the full call hierarchy needs to be + adapted to pass the `system` capability. + + * Introduced the feature for precise tagging of scalar values (#4369). + + Controlled by flag `--experimental-rtti` (off by default). Minor performance changes for + arithmetic expected. We advise to only turn on the feature for testing, as currently no + productive upsides exist (though future improvements will depend on it), and performance + of arithmetic will degrade somewhat. See the PR for the whole picture. + +* motoko-base + + * Added `Option.equal` function (thanks to ByronBecker) (dfinity/motoko-base⁠#615). + +## 0.10.4 (2024-01-10) + +* motoko (`moc`) + + * Officializing the new **incremental garbage collector** after a successful beta testing phase. + The incremental GC can be enabled by the `moc` flag `--incremental-gc` (#3837) and is designed to scale for large program heap sizes. + + **Note**: While resolving scalability issues with regard to the instruction limit of the GC work, it is now possible to hit other scalability limits: + - _Out of memory_: A program can run out of memory if it fills the entire memory space with live objects. + - _Upgrade limits_: When using stable variables, the current mechanism of serialization and deserialization to and from stable memory can exceed the instruction limit or run out of memory. + + **Recommendations**: + - _Test the upgrade_: Thoroughly test the upgrade mechanism for different data volumes and heap sizes and conservatively determine the amount of stable data that is supported when upgrading the program. + - _Monitor the heap size_: Monitor the memory and heap size (`Prim.rts_memory_size()` and `Prim.rts_heap_size()`) of the application in production. + - _Limit the heap size_: Implement a custom limit in the application to keep the heap size and data volume below the scalability limit that has been determined during testing, in particular for the upgrade mechanism. + - _Avoid large allocations per message_: Avoid large allocations of 100 MB or more per message, but rather distribute larger allocations across multiple messages. Large allocations per message extend the duration of the GC increment. Moreover, memory pressure may occur because the GC has a higher reclamation latency than a classical stop-the-world collector. + - _Consider a backup query function_: Depending on the application case, it can be beneficial to offer an privileged _query_ function to extract the critical canister state in several chunks. The runtime system maintains an extra memory reserve for query functions. Of course, such a function has to be implemented with a check that restricts it to authorized callers only. It is also important to test this function well. + - _Last resort if memory would be full_: Assuming the memory is full with objects that have shortly become garbage before the memory space has been exhausted, the canister owner or controllers can call the system-level function `__motoko_gc_trigger()` multiple times to run extra GC increments and complete a GC run, for collecting the latest garbage in a full heap. Up to 100 calls of this function may be needed to complete a GC run in a 4GB memory space. The GC keeps an specific memory reserve to be able to perform its work even if the application has exhausted the memory. Usually, this functionality is not needed in practice but is only useful in such exceptional cases. + + * Allow type annotations on free-standing `object`/`module`/`actor` blocks, in order to perform a conformity check with an interface type (#4324). + +## 0.10.3 (2023-12-20) + +* motoko (`moc`) + + * Include doc comments to Candid interfaces generated via the `--idl` flag (#4334). + + * bugfix: fix broken implementations of `Region.loadNat32`, `Region.storeNat32`, `Region.loadInt32`, `Region.storeInt32` (#4335). + Values previously stored with the broken 32-bit operations must be loaded with care. + If bit 0 is clear, the original value can be obtained by an arithmetic shift right by 1 bit. + If bit 0 is set, the value cannot be trusted and should be ignored + (it encodes some transient address of a boxed value). + +* motoko-base + + * Added `ExperimentalInternetComputer.performanceCounter` function to get the raw performance + counters (dfinity/motoko-base⁠#600). + + * Added `Array.take` function to get some prefix of an array (dfinity/motoko-base⁠#587). + + * Deprecated `TrieSet.mem` in favor of `TrieSet.has` (dfinity/motoko-base⁠#576). + + * bugfix: `Array.chain(as, f)` was incorrectly trapping when `f(a)` was an empty array + (dfinity/motoko-base⁠#599). + +## 0.10.2 (2023-11-12) + +* motoko (`moc`) + + * bugfix: separate tag from underscore in coverage warnings (#4274). + + * Code compiled for targets WASI (`-wasi-system-api`) and pure Wasm (`-no-system-api`) can now + use up to 4GB of (efficiently emulated) stable memory, enabling more offline testing of, for example, + stable data structures built using libraries `Regions.mo` and `ExperimentalStableMemory.mo`. + Note that any Wasm engine (such as `wasmtime`), used to execute such binaries, must support and enable + Wasm features `multi-memory` and `bulk-memory` (as well as the standard NaN canonicalization) (#4256). + + * bugfix: fully implement `Region.loadXXX/storeXXX` for `Int8`, `Int16` and `Float` (#4270). + + * BREAKING CHANGE (Minor): values of type [`Principal`](doc/md/base/Principal.md) are now constrained to contain + at most 29 bytes, matching the IC's notion of principal (#4268). + + In particular: + + * An actor `import` will be statically rejected if the binary representation of the (aliased) textually encoded + principal contains strictly more than 29 bytes. + + * `Principal.fromBlob(b)` will trap if `b` contains strictly more than 29 bytes. + + * The actor literal, `actor `, will trap if the binary representation of + of the textually encoded principal `` contains strictly more than 29 bytes. + +* motoko-base + + * bugfix: fix `Array.tabulateVar` to avoid repeated side-effects (dfinity/motoko-base⁠#596) + +## 0.10.1 (2023-10-16) + +* motoko (`moc`) + + * bugfix: fix assertion failure renaming `or`-patterns (#4236, #4224). + + * bugfix: unsuccessful Candid decoding of an optional array now defaults to null instead of crashing (#4240). + + * bugfix: Candid decoding of an optional, unknown variant with a payload now succeeds instead of crashing (#4238). + + * Implement Prim.textLowercase and Prim.textUppercase (via Rust) (#4216). + + * perf: inline sharable low-level functions in generated coded, + trading code size for reduced cycle count (#4212). + Controlled by flags: + * `-fno-shared-code` (default) + * `-fshared-code` (legacy) + (Helps mitigate the effect of the IC's new cost model, that increases + the cost of function calls). + +* motoko-base + + * Added `Principal.toLedgerAccount` (dfinity/motoko-base⁠#582). + + * Added `Text.toLowercase` and `Text.toUppercase` (dfinity/motoko-base⁠#590). + +## 0.10.0 (2023-09-11) + +* motoko (`moc`) + + * Added a new stable `Region` type of dynamically allocated, independently growable and + isolated regions of IC stable memory (#3768). See documentation. + BREAKING CHANGE: stable memory changes may occur that can prevent returning + to previous `moc` versions. + + * Added doc comments in generated Candid files (#4178). + +* motoko-base + + * Exposed conversions between adjacent fixed-width types (dfinity/motoko-base⁠#585). + + * Added library `Region.mo` offering isolated regions of IC stable memory (dfinity/motoko-base⁠#580). + +## 0.9.8 (2023-08-11) + +* motoko (`moc`) + + * Added numerical type conversions between adjacent fixed-width types (#4139). + + * Administrative: legacy-named release artefacts are no longer created (#4111). + +## 0.9.7 (2023-07-18) + +* motoko (`moc`) + + * Performance improvement: lower the default allocation for bignums (#4102). + + * Performance improvement: generate better code for pattern matches on some small variants (#4093). + + * bugfix: don't crash on import of Candid composite queries (#4128). + +## 0.9.6 (2023-07-07) + +* motoko (`moc`) + + * Allow canister controllers to call the `__motoko_stable_var_info` query endpoint (#4103). + (Previously only self-queries were permitted.) + + * Performance improvement: reduced cycle consumption for allocating objects (#4095). + + * bugfix: reduced memory consumption in the Motoko Playground (#4106). + +## 0.9.5 (2023-07-05) + +* motoko (`moc`) + + * Allow identifiers in `or`-patterns (#3807). + Bindings in alternatives must mention the same identifiers and have compatible types: + ``` Motoko + let verbose = switch result { + case (#ok) "All is good!"; + case (#warning why or #error why) "There is some problem: " # why; + } + ``` + + * Performance improvement: improved cycle consumption allocating fixed-size objects (#4064). + Benchmarks indicate up to 10% less cycles burned for allocation-heavy code, + and 2.5% savings in realistic applications. + + * Administrative: binary build artefacts are now available according to standard naming + conventions (thanks to EnzoPlayer0ne) (#3997). + Please consider transitioning to downloading binaries following the new scheme, + as legacy naming will be discontinued at some point in the future. + +## 0.9.4 (2023-07-01) + +* motoko (`moc`) + + * Allow multiline text literals (#3995). + For example, + ``` + "A horse walks into a bar. + The barman says: `Why the long face?`" + ``` + + parses as: + ``` + "A horse walks into a bar.\nThe barman says: `Why the long face?`" + ``` + + * Added pipe operator ` |> ` and placeholder expression `_` (#3987). + For example: + ``` motoko + Iter.range(0, 10) |> + Iter.toList _ |> + List.filter(_, func n { n % 3 == 0 }) |> + { multiples = _ }; + ``` + + may, according to taste, be a more readable rendition of: + ``` motoko + { multiples = + List.filter( + Iter.toList(Iter.range(0, 10)), + func n { n % 3 == 0 }) }; + ``` + + However, beware the change of evaluation order for code with side-effects. + + * BREAKING CHANGE (Minor): + + New keyword `composite` allows one to declare Internet Computer *composite queries* (#4003). + + For example, + ``` motoko + public shared composite query func sum(counters : [Counter]) : async Nat { + var sum = 0; + for (counter in counters.vals()) { + sum += await counter.peek(); + }; + sum + } + ``` + + has type: + ``` motoko + shared composite query [Counter] -> async Nat + ``` + + and can call both `query` and other `composite query` functions. + + See the documentation for full details. + + * Allow canister imports of Candid service constructors, ignoring the service arguments to + import the instantiated service instead (with a warning) (#4041). + + * Allow optional terminal semicolons in Candid imports (#4042). + + * bugfix: allow signed float literals as static expressions in modules (#4063). + + * bugfix: improved reporting of patterns with record types in error messages (#4002). + +* motoko-base + + * Added more `Array` (and `Text`) utility functions (thanks to roman-kashitsyn) (dfinity/motoko-base⁠#564). + +## 0.9.3 (2023-06-19) + +* motoko (`moc`) + + * Added fields `sender_canister_version` for actor class version tracking (#4036). + +## 0.9.2 (2023-06-10) + +* motoko (`moc`) + + * BREAKING CHANGE (Minor): + + `or`-patterns in function definitions cannot be inferred any more. The new error + message suggests to add a type annotation instead. This became necessary in order + to avoid potentially unsound types (#4012). + + * Added implementation for `ic0.canister_version` as a primitive (#4027). + + * Added a more efficient `Prim.blobCompare` (thanks to nomeata) (#4009). + + * bugfix: minor error in grammar for `async*` expressions (#4005). + +* motoko-base + + * Add `Principal.isController` function (dfinity/motoko-base#558). + ## 0.9.1 (2023-05-15) * motoko (`moc`) @@ -97,7 +606,7 @@ * BREAKING CHANGE (Minor) - Optimized `AssocList.{replace, find}` to avoid unnecesary allocation (dfinity/motoko-base#535, dfinity/motoko-base#539). + Optimized `AssocList.{replace, find}` to avoid unnecessary allocation (dfinity/motoko-base#535, dfinity/motoko-base#539). Note: this subtly changes the order in which the key-value pairs occur after replacement. May affect other containers that use `AssocList`. * Performance improvement: Optimized deletion for `Trie`/`TrieMap` (dfinity/motoko-base#525). @@ -326,7 +835,7 @@ * each `await*` of the same `async*` value repeats its effects. This feature is experimental and may evolve in future. Use with discretion. - See the [manual](doc/md/language-manual.md) for details. + See the [manual](doc/md/reference/language-manual.md) for details. * Suppress GC during IC `canister_heartbeat`, deferring any GC to the scheduled Motoko `heartbeat` `system` method (#3623). This is a temporary workaround, to be removed once DTS is supported for `canister_heartbeat` itself (#3622). diff --git a/LICENSE b/LICENSE index d5dadbd59b1..8ce86e883a6 100644 --- a/LICENSE +++ b/LICENSE @@ -192,7 +192,7 @@ 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] +Copyright 2020 DFINITY Stiftung 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 diff --git a/README.md b/README.md index 32dece9294c..79e0a4d588b 100644 --- a/README.md +++ b/README.md @@ -1,37 +1,36 @@ # [Motoko](https://internetcomputer.org/docs/current/motoko/main/about-this-guide) · [![GitHub license](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Tests](https://img.shields.io/github/actions/workflow/status/dfinity/motoko/release.yml?branch=master&logo=github)](https://github.com/dfinity/motoko/actions?query=workflow:"release") [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/dfinity/motoko/blob/master/Building.md) -A safe, simple, actor-based programming language for authoring [Internet Computer](https://internetcomputer.org/) (IC) canister smart contracts. +A safe, simple, actor-based programming language for building [Internet Computer](https://internetcomputer.org/) (ICP) canister smart contracts. + +![Motoko Logo](https://github.com/user-attachments/assets/844ca364-4d71-42b3-aaec-4a6c3509ee2e) ## User Documentation & Samples -* [Building, installing, and developing on Motoko](Building.md). -* [Overview](doc/md/overview.md). -* [Small samples](samples). -* [Language manual](doc/md/language-manual.md). -* [Concrete syntax](doc/md/examples/grammar.txt). -* [Documentation sources](doc/md/). -* [Base library documentation](doc/md/base/index.md). -* [_Motoko-san_: a prototypical deductive verifier](src/viper/README.md). +* [Introduction](https://internetcomputer.org/docs/current/motoko/main/getting-started/motoko-introduction) +* [Basic concepts and terms](https://internetcomputer.org/docs/current/motoko/main/getting-started/basic-concepts) +* [Sample code](samples) +* [Language manual](doc/md/reference/language-manual.md) +* [Concrete syntax](doc/md/examples/grammar.txt) +* [Documentation sources](doc/md/) +* [Base library documentation](doc/md/base/index.md) +* [_Motoko-san_: a prototypical deductive verifier](src/viper/README.md) ## Introduction ### Motivation and Goals -* High-level language for programming IC applications - -* Simple ("K.I.S.S.") design and familiar syntax for average programmers - -* Good and convenient support for actor model +* High-level programming language for ICP smart contracts -* Good fit for underlying Wasm and IC execution model +* Simple design and familiar syntax -* Anticipate future extensions to Wasm where possible +* Convenient support for the [actor model](https://en.wikipedia.org/wiki/Actor_model) +* Good fit for underlying Wasm and ICP execution model ### Key Design Points -* Simple class-based OO language, objects as closures +* Object-based language with actors, classes, modules, etc. as closures * Classes can be actors @@ -45,7 +44,7 @@ A safe, simple, actor-based programming language for authoring [Internet Compute * Inspirations from Java, C#, JavaScript, Swift, Pony, ML, Haskell -## Related repositories +## Related Repositories * [Base library](https://github.com/dfinity/motoko-base) * [Vessel package manager](https://github.com/dfinity/vessel) @@ -55,10 +54,14 @@ A safe, simple, actor-based programming language for authoring [Internet Compute * [VS Code extension](https://github.com/dfinity/vscode-motoko) · ([install](https://marketplace.visualstudio.com/items?itemName=dfinity-foundation.vscode-motoko)) * [Browser and Node.js bindings](https://github.com/dfinity/node-motoko) · ([npm package](https://www.npmjs.com/package/motoko)) -## Community resources +## Community Resources * [Awesome Motoko](https://github.com/motoko-unofficial/awesome-motoko#readme) * [Blocks - an online low-code editor for Motoko](https://github.com/Blocks-Editor/blocks) * [MOPS - a Motoko package manager hosted on the IC](https://j4mwm-bqaaa-aaaam-qajbq-cai.ic0.app/) * [Motoko Bootcamp](https://github.com/motoko-bootcamp/bootcamp#readme) · ([YouTube channel](https://www.youtube.com/channel/UCa7_xHjvOESf9v281VU4qVw)) * [Motoko library starter template](https://github.com/ByronBecker/motoko-library-template) + +## Contributing + +See our [contribution guidelines](.github/CONTRIBUTING.md) and [code of conduct](.github/CODE_OF_CONDUCT.md) to get started. diff --git a/add-tags.sh b/add-tags.sh deleted file mode 100755 index e993c1c341f..00000000000 --- a/add-tags.sh +++ /dev/null @@ -1,28 +0,0 @@ -#!/usr/bin/env bash - -if ! test -d "$1" -o -d "$2" -o -d "$3" -then - echo "Adds tags to the motoko and motoko-base repository based on sdk repository tags" - echo "and tracing the nix pins. Runs git push --tags!" - echo - echo "Usage: $0 ../sdk ./ ../motoko-base" - echo - echo "(i.e. paths to sdk, motoko and motoko-base repos)" - exit 1 -fi - -set -e - -git -C "$1" fetch --tags -# 0.5.10 was the first where we have motoko-base via motoko -for tag in $(git -C "$1" tag --contains 0.5.10 | sort -V) -do - mo_rev="$(git -C "$1" show "$tag:nix/sources.json" | jq -r .motoko.rev)" - base_rev="$(git -C "$2" show "$mo_rev:nix/sources.json" | jq -r .'["motoko-base"]'.rev)" - echo "$tag: motoko $mo_rev, motoko-base $base_rev" - git -C "$2" tag -f "sdk-$tag" "$mo_rev" - git -C "$3" tag -f "dfx-$tag" "$base_rev" -done - -git -C "$2" push --tags -git -C "$3" push --tags diff --git a/bin/wrapper.sh b/bin/wrapper.sh index 45b7b341078..5131878d71d 100755 --- a/bin/wrapper.sh +++ b/bin/wrapper.sh @@ -18,7 +18,7 @@ declare -A envs # list of expected environment variables with paths to products # Define build products here real[moc]=src/moc hint[moc]="make -C $rel_root/src moc" -envs[moc]="MOC_NON_INCREMENTAL_RELEASE_RTS MOC_NON_INCREMENTAL_DEBUG_RTS MOC_INCREMENTAL_RELEASE_RTS MOC_INCREMENTAL_DEBUG_RTS" +envs[moc]="MOC_NON_INCREMENTAL_RELEASE_RTS MOC_NON_INCREMENTAL_DEBUG_RTS MOC_INCREMENTAL_RELEASE_RTS MOC_INCREMENTAL_DEBUG_RTS MOC_EOP_RELEASE_RTS MOC_EOP_DEBUG_RTS" real[mo-ld]=src/mo-ld hint[mo-ld]="make -C $rel_root/src mo-ld" real[mo-doc]=src/mo-doc @@ -32,10 +32,12 @@ hint[candid-tests]="make -C $rel_root/src candid-tests" rts_hint="make -C $rel_root/rts" -real[MOC_NON_INCREMENTAL_RELEASE_RTS]=rts/mo-rts.wasm -real[MOC_NON_INCREMENTAL_DEBUG_RTS]=rts/mo-rts-debug.wasm +real[MOC_NON_INCREMENTAL_RELEASE_RTS]=rts/mo-rts-non-incremental.wasm +real[MOC_NON_INCREMENTAL_DEBUG_RTS]=rts/mo-rts-non-incremental-debug.wasm real[MOC_INCREMENTAL_RELEASE_RTS]=rts/mo-rts-incremental.wasm real[MOC_INCREMENTAL_DEBUG_RTS]=rts/mo-rts-incremental-debug.wasm +real[MOC_EOP_RELEASE_RTS]=rts/mo-rts-eop.wasm +real[MOC_EOP_DEBUG_RTS]=rts/mo-rts-eop-debug.wasm for var in ${envs[moc]}; do hint[$var]=$rts_hint diff --git a/ci.nix b/ci.nix index e996e270985..fed5b421751 100644 --- a/ci.nix +++ b/ci.nix @@ -1,22 +1,20 @@ -{ src ? { rev = null; }, labels ? {}, releaseVersion ? "latest" }: +{ src ? { rev = null; }, labels ? { }, releaseVersion ? "latest" }: let nixpkgs = import ./nix { }; - inject-rev = drv: drv.overrideAttrs (attrs: { rev = src.rev; }); - removeRecurseForDerivations = nixpkgs.lib.filterAttrsRecursive (k: v: k != "recurseForDerivations"); + inject-rev = drv: drv.overrideAttrs { rev = src.rev; }; + removeRecurseForDerivations = + nixpkgs.lib.filterAttrsRecursive (k: v: k != "recurseForDerivations"); - linux = removeRecurseForDerivations (import ./default.nix { system = "x86_64-linux"; }); - darwin = removeRecurseForDerivations (import ./default.nix { system = "x86_64-darwin"; }); + linux = removeRecurseForDerivations + (import ./default.nix { system = "x86_64-linux"; }); + darwin = removeRecurseForDerivations + (import ./default.nix { system = "x86_64-darwin"; }); - all-systems-go = - nixpkgs.releaseTools.aggregate { - name = "all-systems-go"; - constituents = [ - linux.all-systems-go - darwin.all-systems-go - ]; - }; -in -linux // { + all-systems-go = nixpkgs.releaseTools.aggregate { + name = "all-systems-go"; + constituents = [ linux.all-systems-go darwin.all-systems-go ]; + }; +in linux // { darwin = darwin.all-systems-go; all-systems-go = inject-rev all-systems-go; } diff --git a/default.nix b/default.nix index a0f22b651f0..d1b13ca8e4f 100644 --- a/default.nix +++ b/default.nix @@ -6,6 +6,8 @@ let nixpkgs = import ./nix { inherit system; }; in +assert !officialRelease || nixpkgs.lib.asserts.assertOneOf "system" system [ "x86_64-linux" "x86_64-darwin" ]; + let releaseVersion = import nix/releaseVersion.nix { pkgs = nixpkgs; inherit officialRelease; }; in let stdenv = nixpkgs.stdenv; in @@ -23,13 +25,18 @@ let ic-ref-run = let haskellPackages = nixpkgs.haskellPackages.override { overrides = import nix/haskell-packages.nix nixpkgs subpath; }; in + +let emscripten = nixpkgs.emscripten.overrideAttrs (oldAttrs: { + patches = (oldAttrs.patches or []) ++ [ + nix/emscripten-fix.patch + ]; + }); +in + let rtsBuildInputs = with nixpkgs; [ - # pulls in clang (wrapped) and clang-13 (unwrapped) - llvmPackages_13.clang - # pulls in wasm-ld - llvmPackages_13.lld - llvmPackages_13.bintools + llvmPackages_18.clang + llvmPackages_18.bintools rustc-nightly cargo-nightly wasmtime @@ -42,17 +49,17 @@ let llvmEnv = '' # When compiling to wasm, we want to have more control over the flags, # so we do not use the nix-provided wrapper in clang - export WASM_CLANG="clang-13" + export WASM_CLANG="clang-18" export WASM_LD=wasm-ld # because we use the unwrapped clang, we have to pass in some flags/paths # that otherwise the wrapped clang would take care for us - export WASM_CLANG_LIB="${nixpkgs.llvmPackages_13.clang-unwrapped.lib}" + export WASM_CLANG_LIB="${nixpkgs.llvmPackages_18.clang-unwrapped.lib}" # When compiling natively, we want to use `clang` (which is a nixpkgs # provided wrapper that sets various include paths etc). # But for some reason it does not handle building for Wasm well, so - # there we use plain clang-13. There is no stdlib there anyways. - export CLANG="${nixpkgs.clang_13}/bin/clang" + # there we use plain clang-18. There is no stdlib there anyways. + export CLANG="${nixpkgs.clang_18}/bin/clang" ''; in @@ -83,11 +90,9 @@ let commonBuildInputs = pkgs: pkgs.ocamlPackages.ppxlib pkgs.ocamlPackages.ppx_blob pkgs.ocamlPackages.ppx_inline_test - pkgs.ocamlPackages.ocaml-migrate-parsetree - pkgs.ocamlPackages.ppx_tools_versioned pkgs.ocamlPackages.bisect_ppx - pkgs.ocamlPackages.obelisk pkgs.ocamlPackages.uucp + pkgs.obelisk pkgs.perl pkgs.removeReferencesTo ]; in @@ -144,15 +149,6 @@ let ocaml_exe = name: bin: rts: $out/bin/* --help >/dev/null ''; }; - - musl-wasi-sysroot = stdenv.mkDerivation { - name = "musl-wasi-sysroot"; - src = nixpkgs.sources.musl-wasi; - phases = [ "unpackPhase" "installPhase" ]; - installPhase = '' - make SYSROOT="$out" include_dirs - ''; - }; in rec { @@ -162,14 +158,14 @@ rec { cargoVendorTools = nixpkgs.rustPlatform.buildRustPackage rec { name = "cargo-vendor-tools"; src = subpath "./rts/${name}/"; - cargoSha256 = "sha256-gzLk4kNBSbd8ujJ/7mNs/vwCu76ASqtyoVU84PdaJCw="; + cargoSha256 = "sha256-E6GTFvmZMjGsVlec7aH3QaizqIET6Dz8Csh0N1jeX+M="; }; # Path to vendor-rust-std-deps, provided by cargo-vendor-tools vendorRustStdDeps = "${cargoVendorTools}/bin/vendor-rust-std-deps"; # SHA256 of Rust std deps - rustStdDepsHash = "sha256-dGQzospDaIlGKWu08b8oaXJgIsniBVxI//zc6/LywIE="; + rustStdDepsHash = "sha256-U4BTr1CzFuOMdyLuhw5ry3/u8bkRiPmnMr4pLo3IdOQ="; # Vendor directory for Rust std deps rustStdDeps = nixpkgs.stdenvNoCC.mkDerivation { @@ -195,7 +191,7 @@ rec { name = "motoko-rts-deps"; src = subpath ./rts; sourceRoot = "rts/motoko-rts-tests"; - sha256 = "sha256-jCk92mPwXd8H8zEH4OMdcEwFM8IiYdlhYdYr+WzDW5E="; + sha256 = "sha256-prLZVOWV3BFb8/nKHyqZw8neJyBu1gs5d0D56DsDV2o="; copyLockfile = true; }; @@ -243,10 +239,9 @@ rec { "directory" = "$(stripHash ${allDeps})" __END__ + ${llvmEnv} export TOMMATHSRC=${nixpkgs.sources.libtommath} - export MUSLSRC=${nixpkgs.sources.musl-wasi}/libc-top-half/musl - export MUSL_WASI_SYSROOT=${musl-wasi-sysroot} ''; doCheck = true; @@ -257,10 +252,12 @@ rec { installPhase = '' mkdir -p $out/rts - cp mo-rts.wasm $out/rts - cp mo-rts-debug.wasm $out/rts + cp mo-rts-non-incremental.wasm $out/rts + cp mo-rts-non-incremental-debug.wasm $out/rts cp mo-rts-incremental.wasm $out/rts cp mo-rts-incremental-debug.wasm $out/rts + cp mo-rts-eop.wasm $out/rts + cp mo-rts-eop-debug.wasm $out/rts ''; # This needs to be self-contained. Remove mention of nix path in debug @@ -270,12 +267,17 @@ rec { -t ${nixpkgs.rustc-nightly} \ -t ${rtsDeps} \ -t ${rustStdDeps} \ - $out/rts/mo-rts.wasm $out/rts/mo-rts-debug.wasm + $out/rts/mo-rts-non-incremental.wasm $out/rts/mo-rts-non-incremental-debug.wasm remove-references-to \ -t ${nixpkgs.rustc-nightly} \ -t ${rtsDeps} \ -t ${rustStdDeps} \ $out/rts/mo-rts-incremental.wasm $out/rts/mo-rts-incremental-debug.wasm + remove-references-to \ + -t ${nixpkgs.rustc-nightly} \ + -t ${rtsDeps} \ + -t ${rustStdDeps} \ + $out/rts/mo-rts-eop.wasm $out/rts/mo-rts-eop-debug.wasm ''; allowedRequisites = []; @@ -320,20 +322,17 @@ rec { }; testDerivationDeps = - (with nixpkgs; [ wabt bash perl getconf moreutils nodejs-16_x ]) ++ + (with nixpkgs; [ wabt bash perl getconf moreutils nodejs-18_x ]) ++ [ filecheck wasmtime ]; # extra deps for test/ld ldTestDeps = - with nixpkgs; [ llvmPackages_13.bintools llvmPackages_13.clang ]; + with nixpkgs; [ llvmPackages_18.lld llvmPackages_18.clang ]; testDerivation = args: stdenv.mkDerivation (testDerivationArgs // args); - ocamlTestDerivation = args: - staticpkgs.stdenv.mkDerivation (testDerivationArgs // args); - # we test each subdirectory of test/ in its own derivation with # cleaner dependencies, for more parallelism, more caching # and better feedback about what aspect broke @@ -365,29 +364,34 @@ rec { # Run a variant with sanity checking on snty_subdir = dir: deps: - (test_subdir dir deps).overrideAttrs (args: { + (test_subdir dir deps).overrideAttrs { EXTRA_MOC_ARGS = "--sanity-checks"; - }); - - generational_gc_subdir = dir: deps: - (test_subdir dir deps).overrideAttrs (args: { - EXTRA_MOC_ARGS = "--generational-gc"; - }); + }; snty_compacting_gc_subdir = dir: deps: - (test_subdir dir deps).overrideAttrs (args: { + (test_subdir dir deps).overrideAttrs { EXTRA_MOC_ARGS = "--sanity-checks --compacting-gc"; - }); + }; snty_generational_gc_subdir = dir: deps: - (test_subdir dir deps).overrideAttrs (args: { + (test_subdir dir deps).overrideAttrs { EXTRA_MOC_ARGS = "--sanity-checks --generational-gc"; - }); + }; snty_incremental_gc_subdir = dir: deps: - (test_subdir dir deps).overrideAttrs (args: { + (test_subdir dir deps).overrideAttrs { EXTRA_MOC_ARGS = "--sanity-checks --incremental-gc"; - }); + }; + + enhanced_orthogonal_persistence_subdir = dir: deps: + (test_subdir dir deps).overrideAttrs { + EXTRA_MOC_ARGS = "--enhanced-orthogonal-persistence"; + }; + + snty_enhanced_orthogonal_persistence_subdir = dir: deps: + (test_subdir dir deps).overrideAttrs { + EXTRA_MOC_ARGS = "--sanity-checks --enhanced-orthogonal-persistence"; + }; perf_subdir = dir: deps: (test_subdir dir deps).overrideAttrs (args: { @@ -412,7 +416,7 @@ rec { buildInputs = [ moc wasmtime haskellPackages.qc-motoko nixpkgs.drun ]; checkPhase = '' - export LANG=C.utf8 # for haskell + export LANG=C.utf8 # for haskell qc-motoko${nixpkgs.lib.optionalString (replay != 0) " --quickcheck-replay=${toString replay}"} ''; @@ -423,14 +427,14 @@ rec { buildInputs = [ moc haskellPackages.lsp-int ]; checkPhase = '' echo running lsp-int - export LANG=C.utf8 # for haskell + export LANG=C.utf8 # for haskell lsp-int ${mo-ide}/bin/mo-ide . ''; }; - unit = ocamlTestDerivation { + unit = testDerivation { src = subpath ./src; - buildInputs = commonBuildInputs staticpkgs; + buildInputs = commonBuildInputs nixpkgs; checkPhase = '' patchShebangs . make DUNE_OPTS="--display=short" unit-tests @@ -447,27 +451,28 @@ rec { ''; }; - profiling-graphs = testDerivation { - src = test_src "perf"; - buildInputs = - (with nixpkgs; [ perl wabt wasm-profiler-instrument wasm-profiler-postproc flamegraph-bin ]) ++ - [ moc nixpkgs.drun ]; - checkPhase = '' - patchShebangs . - type -p moc && moc --version - type -p drun && drun --help - ./profile-report.sh - ''; - installPhase = '' - mv _profile $out; - mkdir -p $out/nix-support - echo "report flamegraphs $out index.html" >> $out/nix-support/hydra-build-products - ''; - }; + # wasm-profiler is not compatible with passive data segments and memory64 + # profiling-graphs = testDerivation { + # src = test_src "perf"; + # buildInputs = + # (with nixpkgs; [ perl wabt wasm-profiler-instrument wasm-profiler-postproc flamegraph-bin ]) ++ + # [ moc nixpkgs.drun ]; + # checkPhase = '' + # patchShebangs . + # type -p moc && moc --version + # type -p drun && drun --help + # ./profile-report.sh + # ''; + # installPhase = '' + # mv _profile $out; + # mkdir -p $out/nix-support + # echo "report flamegraphs $out index.html" >> $out/nix-support/hydra-build-products + # ''; + #}; fix_names = builtins.mapAttrs (name: deriv: - deriv.overrideAttrs (_old: { name = "test-${name}"; }) + deriv.overrideAttrs { name = "test-${name}"; } ); coverage = testDerivation { @@ -499,23 +504,32 @@ rec { in fix_names ({ run = test_subdir "run" [ moc ] ; run-dbg = snty_subdir "run" [ moc ] ; + run-eop-release = enhanced_orthogonal_persistence_subdir "run" [ moc ]; + run-eop-debug = snty_enhanced_orthogonal_persistence_subdir "run" [ moc ]; # ic-ref-run = test_subdir "run-drun" [ moc ic-ref-run ]; drun = test_subdir "run-drun" [ moc nixpkgs.drun ]; drun-dbg = snty_subdir "run-drun" [ moc nixpkgs.drun ]; drun-compacting-gc = snty_compacting_gc_subdir "run-drun" [ moc nixpkgs.drun ] ; drun-generational-gc = snty_generational_gc_subdir "run-drun" [ moc nixpkgs.drun ] ; drun-incremental-gc = snty_incremental_gc_subdir "run-drun" [ moc nixpkgs.drun ] ; + drun-eop-release = enhanced_orthogonal_persistence_subdir "run-drun" [ moc nixpkgs.drun ] ; + drun-eop-debug = snty_enhanced_orthogonal_persistence_subdir "run-drun" [ moc nixpkgs.drun ] ; fail = test_subdir "fail" [ moc ]; + fail-eop = enhanced_orthogonal_persistence_subdir "fail" [ moc ]; repl = test_subdir "repl" [ moc ]; ld = test_subdir "ld" ([ mo-ld ] ++ ldTestDeps); + ld-eop = enhanced_orthogonal_persistence_subdir "ld" ([ mo-ld ] ++ ldTestDeps); idl = test_subdir "idl" [ didc ]; mo-idl = test_subdir "mo-idl" [ moc didc ]; + mo-idl-eop = enhanced_orthogonal_persistence_subdir "mo-idl" [ moc didc ]; trap = test_subdir "trap" [ moc ]; + trap-eop = enhanced_orthogonal_persistence_subdir "trap" [ moc ]; run-deser = test_subdir "run-deser" [ deser ]; perf = perf_subdir "perf" [ moc nixpkgs.drun ]; - bench = perf_subdir "bench" [ moc nixpkgs.drun ]; - viper = test_subdir "viper" [ moc nixpkgs.which nixpkgs.openjdk nixpkgs.z3 ]; - inherit qc lsp unit candid profiling-graphs coverage; + bench = perf_subdir "bench" [ moc nixpkgs.drun ic-wasm ]; + viper = test_subdir "viper" [ moc nixpkgs.which nixpkgs.openjdk nixpkgs.z3_4_12 ]; + # TODO: profiling-graph is excluded because the underlying partity_wasm is deprecated and does not support passive data segments and memory64. + inherit qc lsp unit candid coverage; }) // { recurseForDerivations = true; }; samples = stdenv.mkDerivation { @@ -539,7 +553,7 @@ rec { buildInputs = commonBuildInputs nixpkgs ++ [ nixpkgs.ocamlPackages.js_of_ocaml nixpkgs.ocamlPackages.js_of_ocaml-ppx - nixpkgs.nodejs-16_x + nixpkgs.nodejs-18_x nixpkgs.nodePackages.terser ]; buildPhase = '' @@ -559,7 +573,7 @@ rec { doInstallCheck = true; test = ./test + "/test-${n}.js"; installCheckPhase = '' - NODE_PATH=$out/bin node $test + NODE_PATH=$out/bin node --experimental-wasm-memory64 $test ''; }; in @@ -570,13 +584,31 @@ rec { recurseForDerivations = true; }; - inherit (nixpkgs) wabt wasmtime wasm; + inherit (nixpkgs) drun wabt wasmtime wasm nix-update; filecheck = nixpkgs.runCommandNoCC "FileCheck" {} '' mkdir -p $out/bin cp ${nixpkgs.llvm}/bin/FileCheck $out/bin ''; + ic-wasm = + nixpkgs.rustPlatform.buildRustPackage { + name = "ic-wasm"; + src = nixpkgs.sources.ic-wasm; + cargoSha256 = "sha256-lQ4I6Fmodi0jxVuWPSvxbOpXcEX+0Lny7/N3GpW8UUI="; + doCheck = false; + patchPhase = '' + mkdir -p .cargo + cat > .cargo/config.toml << EOF +[target.x86_64-apple-darwin] +rustflags = [ "-C", "linker=c++" ] + +[target.aarch64-apple-darwin] +rustflags = [ "-C", "linker=c++" ] +EOF + ''; + }; + # gitMinimal is used by nix/gitSource.nix; building it here warms the nix cache inherit (nixpkgs) gitMinimal; @@ -689,15 +721,13 @@ rec { mkdir -p $out ln -s ${base-doc} $out/base-doc ln -s ${docs} $out/docs - ln -s ${tests.profiling-graphs} $out/flamegraphs ln -s ${tests.coverage} $out/coverage cd $out; # generate a simple index.html, listing the entry points ( echo docs/overview-slides.html; echo docs/html/motoko.html; echo base-doc/ - echo coverage/ - echo flamegraphs/ ) | \ + echo coverage/ ) | \ tree -H . -l --fromfile -T "Motoko build reports" > index.html ''; @@ -715,7 +745,7 @@ rec { name = "check-grammar"; src = subpath ./src/gen-grammar; phases = "unpackPhase buildPhase installPhase"; - buildInputs = [ nixpkgs.diffutils nixpkgs.bash nixpkgs.ocamlPackages.obelisk ]; + buildInputs = [ nixpkgs.diffutils nixpkgs.bash nixpkgs.obelisk ]; buildPhase = '' patchShebangs . ./gen-grammar.sh ${./src/mo_frontend/parser.mly} > expected @@ -758,7 +788,7 @@ rec { base-doc docs report-site - ic-ref-run + # ic-ref-run shell check-formatting check-rts-formatting @@ -766,8 +796,9 @@ rec { check-grammar check-error-codes ] ++ - builtins.attrValues tests ++ - builtins.attrValues js; + builtins.attrValues tests + ++ builtins.attrValues js + ; }; viperServer = nixpkgs.fetchurl { @@ -788,25 +819,26 @@ rec { let dont_build = [ moc mo-ld didc deser candid-tests ] ++ builtins.attrValues coverage_bins; - in - nixpkgs.lib.lists.unique (builtins.filter (i: !(builtins.elem i dont_build)) ( + in with nixpkgs; + [ ic-wasm ] ++ + lib.lists.unique (builtins.filter (i: !(builtins.elem i dont_build)) ( commonBuildInputs nixpkgs ++ rts.buildInputs ++ js.moc.buildInputs ++ docs.buildInputs ++ check-rts-formatting.buildInputs ++ builtins.concatMap (d: d.buildInputs or []) (builtins.attrValues tests) ++ - [ nixpkgs.ncurses - nixpkgs.ocamlPackages.merlin - nixpkgs.ocamlformat - nixpkgs.ocamlPackages.utop - nixpkgs.fswatch - nixpkgs.niv - nixpkgs.nix-update - nixpkgs.rlwrap # for `rlwrap moc` - nixpkgs.difftastic - nixpkgs.openjdk nixpkgs.z3 nixpkgs.jq # for viper dev - ] ++ nixpkgs.lib.optional stdenv.isDarwin nixpkgs.darwin.apple_sdk.frameworks.Security + [ ncurses + ocamlPackages.merlin + ocamlPackages.utop + ocamlformat + fswatch + niv + nix-update + rlwrap # for `rlwrap moc` + openjdk z3_4_12 # for viper dev + difftastic + ] ++ lib.optional stdenv.isDarwin darwin.apple_sdk.frameworks.Security )); shellHook = llvmEnv + '' @@ -818,8 +850,6 @@ rec { ''; ESM=nixpkgs.sources.esm; TOMMATHSRC = nixpkgs.sources.libtommath; - MUSLSRC = "${nixpkgs.sources.musl-wasi}/libc-top-half/musl"; - MUSL_WASI_SYSROOT = musl-wasi-sysroot; LOCALE_ARCHIVE = nixpkgs.lib.optionalString stdenv.isLinux "${nixpkgs.glibcLocales}/lib/locale/locale-archive"; MOTOKO_BASE = base-src; CANDID_TESTS = "${nixpkgs.sources.candid}/test"; diff --git a/design/Custom-Sections.md b/design/Custom-Sections.md index 35f70d7cb68..fe0d8cba31e 100644 --- a/design/Custom-Sections.md +++ b/design/Custom-Sections.md @@ -34,3 +34,7 @@ let hash : string -> int32 = fun s -> (Lib.String.explode s) ) ``` + +Motoko generates an additional `"enhanced-orthogonal-persistence"` private custom section to +mark Motoko Wasm binaries that rely on IC's support to retain the main Wasm memory on an upgrade, +cf. [Orthogonal Persistence](OrthogonalPersistence.md). diff --git a/design/DFX-Interface.md b/design/DFX-Interface.md index bca70ebb6cb..8e6c565890a 100644 --- a/design/DFX-Interface.md +++ b/design/DFX-Interface.md @@ -48,14 +48,14 @@ Compiling Motoko Files to Wasm ------------------------------ In order to compile a Motoko file, `dfx` invokes `moc` with - - moc some/path/input.mo \ - -o another/path/output.wasm \ - { --package pkgname pkgpath } \ - { --actor-alias alias url } \ - [ --actor-idl actorpath ] \ - { --public-metadata name } - +``` +moc some/path/input.mo \ + -o another/path/output.wasm \ + { --package pkgname pkgpath } \ + { --actor-alias alias url } \ + [ --actor-idl actorpath ] \ + { --public-metadata name } +``` This _reads_ the following files * `some/path/input.mo` * any `.mo` file referenced by `some/path/input.mo`, either relatively, absolutely or via the provided package aliases @@ -118,29 +118,37 @@ used only in very specific cases. The above metadata is stored in the Wasm module, and is only accessible by the controllers of the canister, unless the metadata name is specified in the `--public-metadata` flag. +Moreover, the compiler generates a special marker custom section `"enhanced-orthogonal-persistence"` if the new orthogonal +persistence support is enabled, see [Orthogonal Persistence](OrthogonalPersistence.md). This section is always private and +always emited independent of the compiler flags `--public-metadata` or `--public-metadata`. + Checking stable type compatibility ---------------------------------- The command - - moc --stable-compatible old.most new.most - +``` +moc --stable-compatible old.most new.most +``` checks if the stable interface can evolve from `old.most` to `new.most` in a type safe way without unintentional data loss. If the check succeeds, nothing will be printed. If the check fails, the error message will be printed in stderr and the command returns with exit code 1. +The check can also emit warning messages, e.g. if stable variables are dropped. + +With [enhanced orthogonal persistence](OrthogonalPersistence.md), the stable compatibility is also integrated in the runtime +system, to atomically guarantee memory compatibility during an upgrade. Invoking the IDE ---------------- In order to start the language server, `dfx` invokes - - mo-ide --canister-main some/path/main.mo \ - { --package pkgname pkgpath } \ - { --actor-alias alias url } \ - [ --actor-idl actorpath ] - +``` +mo-ide --canister-main some/path/main.mo \ + { --package pkgname pkgpath } \ + { --actor-alias alias url } \ + [ --actor-idl actorpath ] +``` with `stdin` and `stdout` connected to the LSP client. This may _read_ the same files as `moc` would. @@ -149,21 +157,21 @@ Listing dependencies -------------------- The command - - moc --print-deps some/path/input.mo - +``` +moc --print-deps some/path/input.mo +``` prints to the standard output all URLs _directly_ imported by `some/path/input.mo`, one per line. Each line outputs the original URL, and optionally a full path if `moc` can resolve the URL, separated by a space. For example, - - mo:base/List - mo:other_package/Some/Module - ic:em77e-bvlzu-aq - canister:alias - ./local_import some/path/local_import.mo - ./runtime some/path/runtime.wasm - +``` +mo:base/List +mo:other_package/Some/Module +ic:em77e-bvlzu-aq +canister:alias +./local_import some/path/local_import.mo +./runtime some/path/runtime.wasm +``` This _reads_ only `some/path/input.mo`, and writes no files. By transitively exploring the dependency graph using this command (and @@ -175,11 +183,11 @@ Generating documentation ------------------------ In order to generate documentation for a given Motoko package `dfx` invokes - - mo-doc - [ --source source_dir ] - [ --output output_dir ] - [ --format html|adoc ] - +``` +mo-doc + [ --source source_dir ] + [ --output output_dir ] + [ --format html|adoc ] +``` The default source directory is `src`, the default output is `docs`, and the default format is `html`. `mo-doc` will then generate documentation in the output directory mirroring the directory/file structure of the source directory. diff --git a/design/GraphCopyStabilization.md b/design/GraphCopyStabilization.md new file mode 100644 index 00000000000..aa125afc896 --- /dev/null +++ b/design/GraphCopyStabilization.md @@ -0,0 +1,132 @@ +# Graph-Copy-Based Stabilization + +This is part of the enhanced orthogonal persistence support, see [Orthogonal Persistence](OrthogonalPersistence.md). + +## Purpose +This allows future potentially radical changes of the persistent memory layout, such as introducing a new GC, rearranging persistent metadata, or specializing arrays for small element types etc. +This also relies on precise value tagging to allow more advanced changes that require value metadata, e.g. specializing arrays for small value element types or even downgrading to 32-bit heap layouts (provided that the amount of live data fits into a 32-bit memory). + +## Design +Graph copy of sub-graph of stable objects from main memory to stable memory and vice versa on upgrades. + +## Properties +* Preserve sharing for all objects like in the heap. +* Allow the serialization format to be independent of the main memory layout. +* Limit the additional main memory needed during serialization and deserialization. +* Avoid deep call stack recursion (stack overflow). +* Allows arbitrarily long large stabilization/destabilization due to incremental mechanism (see below). + +## Memory Compatibility Check +Apply a memory compatibility check analogous to the enhanced orthogonal persistence, since the upgrade compatibility of the graph copy is not identical to the Candid subtype relation. + +## Incremental Upgrade +Supporting arbitrarily large upgrades beyond the instruction limit: +* Splitting the stabilization/destabilization in multiple asynchronous messages. +* Limiting the stabilization work units to fit the update or upgrade messages. +* Blocking other messages during the explicit incremental stabilization. +* Restricting the upgrade functionality to the canister owner and controllers. +* Stopping the GC during the explicit incremental upgrade process. + +**Note**: Graph copying needs to be explicitly initiated as the usual upgrade engages enhanced orthogonal persistence, simply retaining main memory with compatibility check. + +### Usage +When upgrading to a Motoko version that is not compatible with the current enhanced orthogonal persistence: + +1. Initiate the explicit stabilization before the upgrade: + +``` +dfx canister call CANISTER_ID __motoko_stabilize_before_upgrade "()" +``` + +* An assertion first checks that the caller is the canister owner or a canister controller. +* All other messages to the canister will be blocked until the upgrade has been successfully completed. +* The GC is stopped. +* If defined, the actor's pre-upgrade function is called before the explicit stabilization. +* The stabilzation runs in possibly multiple asynchronous messages, each with a limited number of instructions. + +2. Run the actual upgrade: + +``` +dfx deploy CANISTER_ID +``` + +* Completes the explicit stabilization if not yet done before this call. +* Perform the actual upgrade of the canister on the IC. +* Detects that graph-copying is in use. +* Clears the heap if enhanced orthogonal persistence is active. +* Start the destabilization with a limited number of steps to fit into the upgrade message. +* If destabilization cannot be completed, the canister does not start the GC and does not accept messages except step 3. + +3. Complete the explicit destabilization after the upgrade: + +``` +dfx canister call CANISTER_ID __motoko_destabilize_after_upgrade "()" +``` + +* An assertion checks that the caller is the canister owner or a canister controller. +* All other messages remain blocked until the successful completion of the destabilization. +* The destabilzation runs in possibly multiple asynchronous messages, each with a limited number of instructions. +* If defined, the actor's post-upgrade function is called at the end of the explicit destabilization. +* The GC is restarted. + +### Remarks +* When receiving the `dfx` error "The request timed out." during explicit stabilization, upgrade, or destabilization, one can simply repeat the call until it completes. +* Steps 3 (explicit destabilization) may not be needed if the corresponding operation fits into the upgrade message. +* Stabilization and destabilization steps are limited to the increment limits: + + Operation | Message Type | IC Instruction Limit | **Increment Limit** + ----------|--------------|----------------------|-------------------- + **Explicit (de)stabilization step** | Update | 20e9 | **16e9** + **Actual upgrade** | Upgrade | 200e9 | **160e9** + +* The graph copy steps also limit the amount of processed stable data (read or write), in order not to exceed the +IC's stable memory access limits. + + Operation | Message Type | IC Stable Access Limit | **Increment Limit** + ----------|--------------|----------------------|-------------------- + **Explicit (de)stabilization step** | Update | 2 GB | **1 GB** + **Actual upgrade** | Upgrade | 8 GB | **6 GB** + +## Graph-Copy Algorithm +Applying Cheney’s algorithm [1, 2] for both serialization and deserialization: + +### Serialization +* Cheney’s algorithm using main memory as from-space and stable memory as to-space: +* Focusing on stable variables as root (sub-graph of stable objects). +* The target pointers and Cheney’s forwarding pointers denote the (skewed) offsets in stable memory. +* Using streaming reads for the `scan`-pointer and streaming writes for the `free`-pointer in stable memory. + +### Deserialization +* Cheney’s algorithm using stable memory as from-space and main memory as to-space: +* Starting with the stable root created during the serialization process. +* A scan stack is used in the main memory to remember the deserialized objects for later scanning. +* Objects are allocated in main memory using the default allocator. +* Using random read/write access on the stable memory. + +## Stable Format +For a long-term perspective, the object layout of the serialized data in the stable memory is fixed and independent of the main memory layout. +* Pointers are represented in 64-bit like main memory in enhanced orthogonal persistence. +* The Brooks forwarding pointer used by the incremental GC is omitted. +* The pointers encode skewed stable memory offsets to the corresponding target objects. +* References to the null objects are encoded by a defined null sentinel value. +* `BigInt` are explicitly serialized in a defined portable little endian representation, without that the serialization or deserialization allocates temporary objects. +The format is also versioned to allow future refinements of the graph copy algorithm. + +## Specific Aspects +* Field hashes in objects are serialized in a blob. On deserialization, the hash blob is allocated in the dynamic heap. Same-typed objects that have been created by the same program version share the same hash blob. +* Stable records can dynamically contain non-stable fields due to structural sub-typing. A dummy value can be serialized for such fields as a new program version can no longer access this field through the stable types. +* For backwards compatibility, old Candid destabilization is still supported when upgrading from a program that used older compiler version. +* Incremental GC: Serialization needs to consider Brooks forwarding pointers (not to be confused with the Cheney's forwarding information), while deserialization can deal with partitioned heap that can have internal fragmentation (free space at partition ends). +* The partitioned heap prevents linear scanning of the heap, especially in the presence of large objects that can be placed at a higher partition than subsequently allocated normal-sized objects. For this reason, a scan stack is allocated in the main memory, remembering the deserialized objects that still need to be scanned. With this, the deserialization does not need to make any assumptions of the heap structure (e.g. monotonically increasing allocations, free space markers, empty heap on deserialization start etc.). +* If actor fields are promoted to the `Any` type in a new program version, their content is released in that variable to allow memory reclamation. +* Both stabilization and destabilization read and write data linearly, which is beneficial for guarding a work set limit (number of accessed pages) per IC message. Destabilization is also linear because it deserializes objects in the same order back as they have been serialized. + +## Open Aspects +* Unused fields in stable records that are no longer declared in a new program versions should be removed. This could be done during garbage collection, when objects are moved/evacuated. This scenario equally applies to enhanced orthogonal persistence. +* The scan stack used during destabilization involves dynamic allocations. + +## References + +[1] C. J. Cheney. A Non-Recursive List Compacting Algorithm. Communications of the ACM, 13(11):677-8, November 1970. + +[2] R. Jones and R. Lins. Garbage Collection: Algorithms for Automatic Dynamic Memory Management. Wiley 2003. Algorithm 6.1: Cheney's algorithm, page 123. diff --git a/design/IDL-Motoko.md b/design/IDL-Motoko.md index 9f57fe659aa..a1799593812 100644 --- a/design/IDL-Motoko.md +++ b/design/IDL-Motoko.md @@ -196,8 +196,8 @@ escape_method = (* failure, unsupported *) are idiomatically expressed in the IDL: ``` e((Int, Nat)) = record {int;nat} - e({i:Int, n:Nat)) = record {i:int; n:nat} - e({_0_:Int, _1_:Nat)) = record {0:int; 1:nat} + e({i:Int, n:Nat}) = record {i:int; n:nat} + e({_0_:Int, _1_:Nat}) = record {0:int; 1:nat} ``` * The mapping `i` tries to detect types that can be expressed as @@ -205,7 +205,7 @@ escape_method = (* failure, unsupported *) ``` i(record {int;nat}) = (Int, Nat) i(record {int; nat; foo:text}) = {_0_:Int; _1_:Nat; foo:Text} - i(record {0:Int, 1:Nat)) = {_0_:int; _1_:nat} + i(record {0:int, 1:nat}) = {_0_:Int; _1_:Nat} ``` But note that @@ -221,7 +221,7 @@ escape_method = (* failure, unsupported *) names that are not valid Motoko names (fake hash values): ``` i(record {int; if:text; foobar_:nat; "_0_":bool}) - = (_0_:Int; if_:Text; _1234_:Nat; _4321_:Bool) + = {_0_:Int; if_:Text; _1234_:Nat; _4321_:Bool} ``` This is another source of partiality for `e`: ``` diff --git a/design/Implementation.md b/design/Implementation.md index 341839042f1..9d73ed44efa 100644 --- a/design/Implementation.md +++ b/design/Implementation.md @@ -9,25 +9,29 @@ ## Heap -* Uniform representation with 32 bit word size. +* Uniform representation with a defined word size. +For [enhanced orthogonal persistence](OrthogonalPersistence.md), 64-bit words are used, while for classical persistence, the word size is 32-bit. -* Use pointer tagging in LSB;. - - 0 for pointers, 1 for scalars. - - Scalars are real value shifted left by 1, lowest bit set. - -* Q: Allocation and GC strategies? +* Use pointer tagging in the LSB: + - 1 for pointers, 0 for scalars. + - Scalars are real value shifted left by 1, lowest bit clear. + For [enhanced orthogonal persistence](OrthogonalPersistence.md), the types of scalars are additionally tagged. + +* Garbage collected. ## Primitive types -* Nat and Int compile to heap-allocated big nums; unboxed for small numbers <= 31 bit. +* Nat and Int compile to heap-allocated big nums; unboxed for small numbers `<= 31` bit. -* Nat8/16 compile to unboxed scalars; Nat32/64 are boxed. +* Nat8/16 compile to unboxed scalars; + On a 32-bit heap, Nat32/64 are boxed. + On a 64-bit heap, only Nat64 is boxed, while Nat32 remains unboxed. - May unbox locally. * Characters are scalars (unicode code points). -* Text is heap-allocated. +* Text is heap-allocated. Using ropes for concatenations. ## Tuples @@ -103,6 +107,11 @@ TODO TODO +## Persistence + +Different * [persistence modes](OrthogonalPersistence.md): +* [Enhanced orthogonal persistence](OrthogonalPersistence.md). +* [Classical persistence](OldStableMemory.md). # Hypervisor Extensions needed diff --git a/design/Memory.md b/design/Memory.md index 7f628ad9a11..ab245410cf4 100644 --- a/design/Memory.md +++ b/design/Memory.md @@ -29,8 +29,11 @@ In the future (with the GC proposal), Wasm will have a 4th form of mutable state The Heap is *not* an explicit entity that can be im/exported, only individual references to structures on the heap can be passed. -Note: It is highly likely that most languages implemented on Wasm will eventually use Wasm GC. -Various implementers are currently waiting for it to become available before they start porting their language to Wasm. +Note: It is highly likely that several managed languages implemented on Wasm will eventually use Wasm GC. +However, in our case, it would require snapshotting the Wasm managed heap which is currently not possible for `wasmtime`. +Moreover, the GC implemented on the managed heap does probably not fit the IC with hard instruction limits. +A fully incremental GC would be needed, which is currently not implemented in any Wasm engine (often only using reference counting or a GC that has worst-case unbounded pauses). +Conceptually, enhanced orthogonal persistence could be implemented on Wasm GC. ### Internet Computer (IC) @@ -48,19 +51,16 @@ All references are *sharable*, i.e., can be passed between actors as message arg Other than actors, all reference types must be pure (immutable and without identity) to prevent shared state and allow transparent copying by the implementation. Element buffers can encode arbitrary object trees. -Once Wasm GC is available, some of these types (esp. buffers) could be replaced by proper Wasm types. - - -## Language Implementation +## Language Implementation Rationales ### Representing Data Structures There are 3 possible ways of representing structured data in Wasm/IC. -#### Using Wasm Memory +#### Using Wasm Memory <- Chosen Design -All data structures are laid out and managed in Memory by the compiler and the language runtime. -References are stored via indirections through a Table. +All data structures are laid out and managed in Wasm memory by the compiler and the runtime system. +Function references are stored via indirections through a Wasm table. Pros: 1. local data access maximally efficient @@ -69,7 +69,7 @@ References are stored via indirections through a Table. Cons: 1. message arguments require de/serialisation into IC buffers on both ends (in addition to the de/serialisation steps already performed by IC) 2. each actor must ship its own instance of a GC (for both memory and table) and de/serialisation code - 3. all references require an indirection + 3. all function references require an indirection 4. more implementation effort #### Using IC API @@ -102,88 +102,8 @@ All data structures are represented as Wasm GCed objects. 1. Wasm GC is 1-2 years out 2. unclear how to implement transparent persistence (see below) - ## Persistence -### Persistence models - -There are at least 3 general models for providing persistence. - -#### *Explicit* persistence - -IC API provides explicit system calls to manage persistent data. -Wasm state is volatile; each message received runs in a fresh instance of the actor's module. - - Pros: - 1. easy and efficient to implement - 2. apps have maximal control over persistent data and its layout - - Cons: - 1. bifurcation of state space - 2. programs need to load/store and de/serialise persistent data to/from local state - -#### *Transparent* persistence - -All Wasm state is implicitly made persistent. -Conceptually, each message received runs in the same instance of the actor's module. - - Pros: - 1. "perfect" model of infinitely running program - 2. programmers need to "think" less - - Cons: - 1. hard to implement efficiently without knowing neither language nor application - 2. can easily lead to space leaks or inefficiencies if programmers aren't careful - -#### *Hybrid* persistence -Wasm state entities can be marked as persistent selectively. -Conceptually, each message received runs in the same instance of the actor's module, -but Wasm is extended with some notion of volatile state and reinitialisation. - - Pros: - 1. compromise between other two models - - Cons: - 1. compromise between other two models - 2. creates dangling references between bifurcated state parts - 3. incoherent with Wasm semantics (segments, start function) - -### Implementing Transparent persistence - -#### *High-level* implementation of persistence - -Hypervisor walks data graph (wherever it lives), turns it into merkle tree. - - Pros: - 1. agnostic to implementation details of the engine - 2. agnostic to GC (or subsumes GC) - - Cons: - 1. requires knowledge of and access to data graph - 2. deep mutations result in deep changes in merkle tree (mutation cost is logarithmic in depth) - 3. unclear how to detect changes efficiently - -#### *Low-level* implementation of persistence - -Hypervisor provides memory to Wasm engine, detects dirty pages; could be memory-mapped files. - - Pros: - 1. agnostic to language and data graph - 2. fast when mutation patterns have good locality - 3. can potentially offload much of the implementation to existing hardware/OS/library mechanisms - - Cons: - 1. bad interaction with language-internal GC (mutates large portions of the memory at once) - 2. does not extend to tables (contain position-dependent physical pointers) - 3. no obvious migration path to Wasm GC - 4. dependent on VM specifics (and internals?) - -#### *Selectable* implementation of persistence - -Provide both previous options, possibly in a mutually exclusive fashion. - - Pros: - 1. choice for implementers - - Cons: - 1. maximal complexity for platform +Different * [persistence modes](OrthogonalPersistence.md): +* [Enhanced orthogonal persistence](OrthogonalPersistence.md). +* [Classical persistence](OldStableMemory.md). diff --git a/design/OldStableMemory.md b/design/OldStableMemory.md new file mode 100644 index 00000000000..984b6054fd8 --- /dev/null +++ b/design/OldStableMemory.md @@ -0,0 +1,299 @@ +# Old Stable Memory API + +This describes the legacy stable memory mechanism intended to be replaced by +true orthogonal persistence where the main memory is retained across upgrades. +See `OrthogonalPersistence.md`. + +The current implementation of stable variables is based on +serialization and deserialization of all stable data on upgrade. This +clearly doesn't scale to large amounts of stable data as there may not +be enough cycles to perform (de)serialization. + +To avoid this upgrade hazard, some canisters with low-level API +access, and large stable memory footprints, arrange to store their +persistent data in stable memory at all times, using either a custom +binary encoding or a mixture of candid and raw binary. + +To provide more fine-grained access to stable memory we propose +extending the existing stable variable implementation with an orthogonal, +library providing (almost) direct access to the IC Stable Memory API. + +Since the implementation of stable variables itself makes temporary use of +stable memory, some coordination between these two alternative, co-existing +interfaces to IC stable memory is required. + + +# The IC's Stable Memory API + +The IC provides a very small set of functions for operating on stable memory: + +``` +ic0.stable_size : () -> (page_count : i32); // * +ic0.stable_grow : (new_pages : i32) -> (old_page_count : i32); // * +ic0.stable_write : (offset : i32, src : i32, size : i32) -> (); // * +ic0.stable_read : (dst : i32, offset : i32, size : i32) -> (); // * +``` + +(see https://sdk.dfinity.org/docs/interface-spec/index.html#system-api-stable-memory) + +These grow memory and do bulk transfers between Wasm and stable +memory. The `// *` means that they can be called in all contexts +(e.g. init, update, query etc). Direct reads and writes of word-sized +data to/from the stack are not supported but can be emulated at cost. +The initial size of the stable memory is zero. The contents of fresh pages (after grow) is initially zero. + +Note that, in this API, the client is responsible for growing (both +stable and wasm) memory before access by read or write (out-of-bounds +access will trap). + +# A minimal Stable Memory API + +The minimal Motoko prims could be: + +``` +module StableMemory { + size : () -> (logical_page_count : i32); // <= ic0.stable_size() + grow : () -> (new_pages : i32) -> (old_logical_page_count : i32); + loadNat8 : (offset : Nat32) -> Nat8; + // traps outside logical address space + storeNat8 : (offset : Nat32, n : Nat8) -> (); + // traps outside logical address space + ... + loadBlob : (offset : Nat32, size : Nat) -> Blob + // read Blob contents from memory at [offset,..,offset+size-1] into fresh blob, trapping if exceeding logical address space + storeBlob : (offset : Nat32, b : Blob) -> (); // write contents of blob to memory, trapping if exceeding logical address space +} +``` + +NOTE: Motoko's `Nat32` value are always boxed - it might be more efficient to use [`Nat`](../base/Nat.md) which is unboxed for 30(?)-bit values. + + +``` +fun loadNat8(offset, b) = + assert (offset < StableMemory.size() * wasm_page_size); + mem[offset] + +fun storeNat8(offset, b) = + assert (offset < StableMemory.size() * wasm_page_size); + mem[offset] := b + +``` + +(To avoid overflow on the rhs, we could implement the check as `assert ((offset >> 16) < StableMemory.size())`.) + +On top of this basic API, users should be able to build more +interesting higher-level APIs for pickling user-defined data. + +REMARK: + +Actually implementing the sketched assignments using the existing IC +API involves writing the contents to memory and then copying stable +memory - even for individual words - this could be optimized by an +improved system API offering direct load and stores from/to the stack: + +``` +ic0.stable_write_i32 : (offset : i32, val: i32) -> (); // * +ic0.stable_read_i32 : (offset : i32, size : i32) -> i32; // * +// similarly for i64, f32, f64 +``` + +## Bikeshedding: + +It might be preferable to arrange the API by type, with one nested +module per type: + +``` +module StableMemory { + Nat8 : module { + load : (offset : Nat32) -> Nat8; + store : (offset : Nat32, n : Nat8) -> (); + }; + Nat16 : module { + load : (offset : Nat32) -> Nat16; + store : (offset : Nat32, n : Nat16) -> (); + }; + // uniformly for all scalar prim types. + ... + Blob : module { + read: (offset : Nat32, size : i32) -> Blob + write : (offset : Nat32, b : Blob) -> (); + } +} +``` + +(I think the compiler will still optimize these nested calls to known +function calls, but it would be worth checking). + +# Maintaining existing Stable Variables (Legacy Persistence). + +In classical persistence, stable memory is hidden behind the abstraction of stable +variables, which we will still need to maintain. This old +implementation of stable variables stores all variables as a +Candidish record of _stable_ fields, starting at stable memory address 0 with +initial word encoding size (in bytes?) followed by contents. +(Candidish is the Motoko extension of Candid to support mutable data.) + +Starting from a clean slate, we would extend this so all user-defined StableMemory is +stored at a low address, with _stable variable_ data stored just +beyond the currently used StableMemory content on canister_pre_upgrade +and canister_post_upgrade. That way the StableMemory area need not +move, with stable variables simply serialized and appended in +`canister_pre_upgrade` and deserialized and discarded in +`canister_post_upgrade`, leaving the manual StableMemory unchanged. + +For backwards compatibility reasons, we can't do that. + +Luckily, stable variables always require non-zero bytes to encode, so we +can devise a backwards compatible scheme for upgrading +from pre-StableMemory canisters to post-StableMemory +canisters, as follows. + +During execution, abstract stable memory (StableMemory) is aligned +with IC stable memory, at address 0, for reasonable efficiency (apart +from bound checks against logical `size()`). + +During upgrade, if StableMemory has zero pages, we use the existing format, writing +(non_zero) length and content of any stable variables from address 0 or leaving ic0.stable_mem() +at zero with no pages allocated (if there are no stable variables). +Otherwise, we compute the length and data of the stable variable encoding; +save the first word of StableMemory at a known offset from the end of stable memory; +write a 0x00 marker to the first word; and append length (even if zero) and +data (if any) to the end of StableMem. +The logical size of StableMemory and a version number are also written at +known offsets from the end of StableMemory. + +In post_upgrade, we reverse this process to recover the size of StableMemory, +restore the displaced first word of StableMemory and deserialize any stable vars, +taking care to zero the (logically) free StableMemory occupied by any encoded stable variables +and other metadata (so that initial reads after growing beyond page `size` always return 0). + +This scheme avoids relocating most of StableMem and is constant time when +there are no stable variables. + +[Enhanced orthogonal persistence](OrthogonalPersistence.md) introduces a new peristence implementation. +The old mechanism is only supported for backwards compatibility. + +# Details: + +Stable memory layout (during execution): + +* aligned with stable-memory, with global word `size` holding logical page count (initially 0 < !size < 2^16). +* user are responsible for allocating logical pages. +* each load/store does a `size`-related bounds check. + +During execution, stable variables aren't maintained in stable memory - they are on the Motoko heap. + +Stable memory layout (between upgrades), assuming stable variable encoding `v == {fs:vs}`, a record value of record type `{fs:Ts}`. + +NOTE: A program with no stable variables still writes an empty record value `v = {}`. + +``` +(case !size == 0) // hence N = 0 + [0..3] StableVariable data len + [4..4+len-1] StableVariable data + [len+4..len+12-1] instruction costs of stabilization (optional) + [len+12,..M-1] 0...0 // zero padding +(case !size > 0) +[0..3] 0...0 +[4..N-1] StableMemory bytes +[N..N+3] StableVariable data len +[N+4..(N+4)+len-1] StableVariable data +[(N+4)+len..M-20] 0...0 // zero padding +[M-20..M-13] instruction costs of stabilization (optional) +[M-12..M-9] value N/64Ki = !size +[M-8..M-5] saved StableMemory bytes +[M-4..M-1] version word + +where N = !size * pagesize // logical memory size + M = ic0.stable_size() * pagesize // physical memory size + pagesize = 64Kb (2^16 bytes) +where (len, data) = serialize(v,data) + +``` + +On pre_upgrade + +```ocaml +func stabilise {fs:Ts} v : value = + let len, data = serialize(v) + in + if !size == 0 then + mem[0,..,3] := len + mem[4,...,4+len-1] := data + else + let N = !size * page_size in + // if necessary, grow mem to page including address N + 4 + len + 4 + 4 + 4 + let M = pagesize * ic0.stable_size() in + mem[N,..,N+3] := len + mem[N+4,..,N+4+len-1] := data + mem[M-12..M-9] := !size + men[M-8..M-5] := mem[0,...,3] // save StableMemory bytes 0-3 + mem[0,..,3] := 0..0 // write marker + mem[M-4..M-1] := version +``` +on post_upgrade + +```ocaml +// restores StableMemory (size and memory) and deserializes any stable variables, zeroing their storage +fun destabilize {fs:Ts} : value = + let pages = ic0.stable_size() in + if pages == 0 then + size := 0; + {fs = nulls} + else + let marker = mem[0,..,3] in // read zero or size of stable value + mem[0,..,3] = 0; + let (offset, len) = + if marker == 0x0 then + let M = pages * pagesize in + let ver = mem[M-4,..,M-1] in + mem[M-4,..,M-1] := 0; + if (ver > version) assert false + mem[0,..,3] = mem[M-8,..,M-5]; // restore StableMemory bytes 0-3 + size := mem[M-12,..,M-9]; + mem[M-12,..,M-9] := 0; + N = size * pagesize; + let len = mem[N,..,N+3] in + mem[N,..,N+3] := 0; + assert len > 0 + assert (N+4+len-1 <= ic0.stable_size() * pagesize) + (N+4, len) + else + (4, marker) + in + assert (0 < len <= ic0.stable_size() * pagesize) + let v = deserialise(offset, len) in + mem[offset,..,offset+len-1] := 0 // clear serialization memory + v +``` + +We explicitly clear memory used by stable variables so StableMem +doesn't need to clear memory when grabbing logical pages from already +existing physical ones. + + +NOTE: We still need to do some work during updgrade and postupgrade, +but if stable variables and user-defined pre/post upgrade hooks are +avoided, then the work is minimal and highly unlikely to exhaust cycle +budget. + +REMARK: + +* An actor that has no stable variables and allocates no StableMem + should require no physical stable memory + +* An actor that has n > 0 pages of StableMem will (unfortunately) + require at least n+1 pages of physical memory since we need at least + one extra bit to encode the presence or absence of stable variables + (there is no other preserved state that could record this bit). + +FURTHER CONSIDERATIONS: It would be nice if there was some way to +allow a Motoko actor (perhaps intended to upgrade from a foreign +canister with foreign stable memory format) to have unadulterated, +full-speed access to stable memory, without the protocol required by +the possibility of stable variables. Perhaps we could special case +programs that have *no* stable variables to support this raw +semantics. I.e. if the program declares no stable variables, we +install and upgrade by simply setting `(StableMemory.)size := +ic0.stable_size()`, never consulting or altering physical memory and +(ideally) omitting the additional bounds checking. diff --git a/design/OrthogonalPersistence.md b/design/OrthogonalPersistence.md new file mode 100644 index 00000000000..1a8c1b8c17e --- /dev/null +++ b/design/OrthogonalPersistence.md @@ -0,0 +1,152 @@ + +# Enhanced Orthogonal Persistence + +This implements the vision of **enhanced orthogonal persistence** in Motoko that combines: +* **Stable heap**: Persisting the program main memory across canister upgrades. +* **64-bit heap**: Extending the main memory to 64-bit for large-scaled persistence. + +As a result, the use of secondary storage (explicit stable memory, dedicated stable data structures, DB-like storage abstractions) will no longer be necessary: Motoko developers can directly work on their normal object-oriented program structures that are automatically persisted and retained across program version changes. + +## Activation +Enhanced orthogonal persistence is offered for **beta testing** via the compiler flag `--enhanced-orthogonal-persistence`. +Classical persistence with 32-bit main memory and Candid stabilization currently remains the default mode. +See `design/PersistenceModes.md` for more information. + +## Advantages +Compared to the existing orthogonal persistence in Motoko, this design offers: +* **Performance**: New program versions directly resume from the existing main memory and have access to the memory-compatible data. +* **Scalability**: The upgrade mechanism scales with larger heaps and in contrast to serialization, does not hit IC instruction limits. + +Compared to the explicit use of stable memory, this design improves: +* **Simplicity**: Developers do not need to deal with explicit stable memory. +* **Performance**: No copying to and from the separate stable memory is necessary. + +## Design +The enhanced orthogonal persistence is based on the following main properties: +* Extension of the IC to retain main memory on upgrades. +* Supporting 64-bit main memory on the IC. +* A long-term memory layout that is invariant to new compiled program versions. +* A fast memory compatibility check performed on each canister upgrade. +* Incremental garbage collection using a partitioned heap. + +## IC Main Memory Retention + +The IC introduces a new upgrade option `wasm_memory_persistence` to control the retention of the canister's Wasm main memory. +* `wasm_memory_persistence = opt keep` retains the Wasm main memory and is required for Motoko's enhanced orthogonal persistence. The IC prevents using this options for canisters with classical persistence. +* `wasm_memory_persistence = null` uses the classical persistence, replacing the main memory. However, a safety check is implemented to prevent that main memory is not accidentally dropped for enhanced orthogonal persistence. +* The other option `replace` is not recommended as it drops main memory, even for enhanced orthogonal persistence. + +### Memory Layout +In a co-design between the compiler and the runtime system, the main memory is arranged in the following structure, invariant of the compiled program version: +* Lower 4MB: Rust call stack. +* Space between 4MB and 4.5MB: Limited reserved space Wasm data segments, only used for the Motoko runtime system. +* Between 4.5MB and 5MB: Persistent metadata. +* Thereafter: Dynamic heap space. Fix start address at 5MB. + +### Persistent Metadata +The persistent metadata describes all anchor information for the program to resume after an upgrade. + +More specifically, it comprises: +* A stable heap version that allows evolving the persistent memory layout in the future. +* The stable subset of the main actor, containing all stable variables declared in the main actor. +* A descriptor of the stable static types to check memory compatibility on upgrades. +* The runtime state of the garbage collector, including the dynamic heap metadata and memory statistics. +* A reserve for future metadata extensions. + +### Compatibility Check +Upgrades are only permitted if the new program version is compatible with the old version, such that the runtime system guarantees a compatible memory structure. + +Compatible changes for immutable types are largely analogous to the allowed Motoko subtype relation, e.g. +* Adding or removing actor fields. +* Removing object fields. +* Adding variant fields. +* `Nat` to `Int`. +* Shared function parameter contravariance and return type covariance. + +The existing IDL-subtype functionality is reused with some adjustments to check memory compatibility: The compiler generates the type descriptor, a type table, that is recorded in the persistent metadata. Upon an upgrade, the new type descriptor is compared against the existing type descriptor, and the upgrade only succeeds for compatible changes. + +This compatibility check serves as an additional safety measure on top of the DFX Candid subtype check that can be bypassed by users (when ignoring a warning). Moreover, in some aspects, the memory compatibility rules differ to the Candid sub-type check: +* Top-level actor fields (`stable` fields) can change mutability (`let` to `var` and vice-versa). +* Support of variable (MutBox) with type invariance. +* Types cannot be made optional (no insertion of Option). +* Same arity for function parameters and function return types (no removed optional parameters, no additional optional results). +* Records cannot introduce additional optional fields. +* Same arity for tuple types (no insertion of optional items). +* Records and tuples are distinct. + +### Garbage Collection +The implementation focuses on the incremental GC and abandons the other GCs because the GCs use different memory layouts. For example, the incremental GC uses a partitioned heap with objects carrying a forwarding pointer. + +The incremental GC is chosen because it is designed to scale on large heaps and the stable heap design also aims to increase scalability. + +The garbage collection state needs to be persisted and retained across upgrades. This is because the GC may not yet be completed at the time of an upgrade, such that object forwarding is still in use. The heap partition structure is described by a linked list of partition tables that is reachable from the GC state. + +The garbage collector uses two kinds of roots: +* Persistent roots: These refer to root objects that need to survive canister upgrades. +* Transient roots: These cover additional roots that are only valid in a specific version of a program and are discarded on an upgrade. + +The persistent roots are registered in the persistent metadata and comprise: +* All stable variables of the main actor, only stored during an upgrade. +* The stable type table. + +The transient roots are referenced by the Wasm data segments and comprise: +* All canister variables of the current version, including flexible variables. + +### Main Actor +On an upgrade, the main actor is recreated and existing stable variables are recovered from the persistent root. The remaining actor variables, the flexible fields as well as new stable variables, are (re)initialized. + +As a result, the GC can collect unreachable flexible objects of previous canister versions. Unused stable variables of former versions can also be reclaimed by the GC. + +### No Static Heap +The static heap is abandoned and former static objects need to be allocated in the dynamic heap. This is because these objects may also need to survive upgrades and the persistent main memory cannot accommodate a growing static heap of a new program version in front of the existing dynamic heap. The incremental GC also operates on these objects, meaning that forwarding pointer resolution is also necessary for these objects. + +For memory and runtime efficiency, object pooling is implemented for compile-time-known constant objects (with side-effect-free initialization), i.e. those objects are already created on program initialization/upgrade in the dynamic heap and thereafter the reference to the corresponding prefabricated object is looked up whenever the constant value is needed at runtime. + +The runtime system avoids any global Wasm variables for state that needs to be preserved on upgrades. Instead, such global runtime state is stored in the persistent metadata. + +### Wasm Data Segments +Only passive Wasm data segments are used by the Motoko compiler and runtime system. In contrast to ordinary active data segments, passive segments can be explicitly loaded to a dynamic address. + +This simplifies two aspects: +* The generated Motoko code can contain arbitrarily large data segments (to the maximum that is supported by the IC). The segments can be loaded to the dynamic heap when needed. +* The IC can simply retain the main memory on an upgrade without needing to patch any active data segments of the new program version to the persistent main memory. + +However, more specific handling is required for the Rust-implemented runtime system (RTS): The Rust-generated active data segment of the runtime system is changed to the passive mode and loaded to the expected static address on the program start (canister initialization and upgrade). The location and size of the RTS data segments is therefore limited to a defined reserve of 512 KB, see above. This is acceptable because the RTS only requires a controlled small amount of memory for its data segments, independent of the compiled Motoko program. + +### Null Sentinel +As an optimization, the top-level `null` pointer is represented as a constant sentinel value pointing to the last unallocated Wasm page. This allows fast null tests without involving forwarding pointer resolution of potential non-null comparand pointers. + +### Memory Capacity +The canister has no upfront knowledge of the maximum allocatable Wasm main memory in 64-bit address space, as there is no IC API call to query the main memory limit. This limit may also be increased in future IC releases. + +Therefore, a mechanism is implemented to deal with an unknown and dynamically increasable main memory capacity offered by the IC. This is needed in two cases: + +* GC reserve (strict): The runtime system ensures sufficient free space to allow garbage collection at all times, even if the heap is full. For this purpose, the runtime system already pre-allocates the reserve, to be sure that the reserve is available despite the unknown capacity. As an optimization, this pre-allocation is skipped when the memory demand including the GC reserve is below a guaranteed minimum Wasm memory limit of the IC, e.g. 4GB or 6GB. +* GC scheduling (heuristic): The GC schedules at high frequency when memory is becoming scarce. For this purpose, the GC maintains an assumption of the minimum memory limit and probes the supposed limit when the heap size approaches this limit. If the allocation succeeds, the assumed limit is increased. Otherwise, the critical high-frequency GC scheduling rate is activated. + +In both cases, the runtime system tries to reduce Wasm memory allocations as much as possible, i.e. not pre-allocating memory for small heap sizes, and not probing an allocation in certain memory ranges by assuming that the IC only offers main memory of a certain granularity, e.g. multiples of 2GB. To save instructions, the critical GC scheduling is only activated when reaching the actual memory limit. Moreover, the mechanism can handle an increased memory capacity at runtime, e.g. when the IC is upgraded to a new release with a higher memory limit. + +### Migration Path +When migrating from the old serialization-based stabilization to the new persistent heap, the old data is deserialized one last time from stable memory and then placed in the new persistent heap layout. Once operating on the persistent heap, the system should prevent downgrade attempts to the old serialization-based persistence. + +Assuming that the persistent memory layout needs to be changed in the future, the runtime system supports serialization and deserialization to and from stable memory in a defined data format using graph copy. + +### Graph Copy +The graph copy is an alternative persistence mechanism that will be only used in the rare situation when the persistent memory layout will be changed in the future. Arbitrarily large data can be serialized and deserialized beyond the instruction and working set limit of upgrades: Large data serialization and deserialization is split in multiple messages, running before and/or after the IC upgrade to migrate large heaps. Of course, other messages will be blocked during this process and only the canister owner or the canister controllers are permitted to initiate this process. + +Graph copying needs to be explicitly initiated before an upgrade to new Motoko version that is incompatible to the current enhanced orthogonal persistent layout. For large data, the graph copy needs to be manually completed after the actual upgrade. + +``` +dfx canister call CANISTER_ID __motoko_stabilize_before_upgrade "()" +dfx deploy CANISTER_ID +dfx canister call CANISTER_ID __motoko_destabilze_after_upgrade "()" +``` + +More detailed information and instructions on graph copy are contained in `design/GraphCopyStabilization.md`. + +### Old Stable Memory +The old stable memory remains equally accessible as secondary (legacy) memory with the new support. + +## Current Limitations +* The memory footprint of a program increases with 64 bit as the word size for scalars and pointers are doubled. In turn, in some cases, boxing can be avoided due to larger word size which again reduces memory demand. +* Freeing old object fields: While new program versions can drop object fields, the runtime system should also delete the redundant fields of persistent objects of previous program versions. This could be realized during garbage collection when objects are copied. For this purpose, the runtime system may maintain a set of field hashes in use and consult this table during garbage collection. Another, probably too restrictive solution could be to disallow field removal (subtyping) on object upgrades during the memory compatibility check. diff --git a/design/PersistenceModes.md b/design/PersistenceModes.md new file mode 100644 index 00000000000..520cc8b9fbf --- /dev/null +++ b/design/PersistenceModes.md @@ -0,0 +1,50 @@ +# Persistence Modes + +This Motoko build includes two substantially different persistence modes in one build: + +* [Classical Persistence](OldStableMemory.md) (default): + This is the traditional Motoko compiler design based on 32-bit memory and Candid-based stabilization for upgrades. + This mode is known to have severe scalability problems on upgrades, because the stabilization may exceed upgrade instruction limit for stable data amounts, besides other problems such as exponential duplication or stack overflows depending on the data structures. + The mode is temporarily retained to allow beta testing of the new enhanced orthogonal persistence until the new persistence is officialized. +* [Enhanced Orthogonal Persistence](OrthogonalPersistence.md) (new, for beta testing): + This implements scalable persistence with 64-bit main memory that is retained across upgrades without stabilization to stable memory. + The mode needs to be enabled by the compiler flag `--enhanced-orthogonal-persistence` and is intended to become the future default mode, deprecating classical persistence. + +The reason for having one build instead of two separate branches and release artefact is for having a unified branch, and ensure that new features are implemented and tested for both persistence modes, passing the same CI. + +## Compiler Flags + +* (no flag): Use classical persistence +* `--enhanced-orthogonal-persistence`: Use enhanced orthogonal persistence. NOTE: This is currently in the **beta testing** phase. + +Certain compiler flags are only applicable to a specific persistence mode: + +Flag | Applicable Mode +------------------|---------------- +--rts-stack-pages | Classical persistence only +--stabilization-instruction-limit | Enhanced persistence only +--copying-gc | Classical persistence only +--compacting-gc | Classical persistence only +--generational-gc | Classical persistence only + +(All other flags are applicable to both modes.) + +Incremental graph copy stabilization with `__motoko_stabilize_before_upgrade` and `__motoko_destabilize_after_upgrade` are only available with enhanced orthogonal persistence and only needed in a seldom case of memory layout upgrade. + +## Source Structure + +## Runtime System +The Motoko runtime system (RTS) is a combined source base supporting 3 modes, each with a debug and release build: +* 32-bit classical persistence, with classical non-incremental GCs +* 32-bit classical persistence, with the incremental GC +* 64-bit enhanced orthogonal persistence + +## Compiler +For pragmatic purposes, the compiler backend is split/duplicated in two parts +* `compile-enhanced.ml`: Enhanced orthogonal persistence, 64-bit, passive data segments, incremental graph copy. +* `compile-classical.ml`: Classical persistence, 32-bit, Candid stabilization. + +The linker integrates both persistence modes and 32-bit and 64-bit in one package. + +## Tests +Most tests run on both modes. Specific tests apply to selected modes, as defined by the `ENHANCED-ORTHOGONAL-PERSISTENCE` or `CLASSICAL-PERSISTENCE` tags. diff --git a/design/Stable.md b/design/Stable.md index 6fd40a09174..63a59318256 100644 --- a/design/Stable.md +++ b/design/Stable.md @@ -22,10 +22,12 @@ Concretely, the syntax of `` is extended as follows: ``` Additional restrictions apply: -* Either a `stable` or `flexible` modifier _must_ appear on `let` and `var` declarations that are actor fields. +* A `stable` or `flexible` modifier _can_ appear on `let` and `var` declarations that are actor fields. * A `stable` or `flexible` modifier _must not_ appear anywhere else. -Both restrictions may be relaxed in the future. +Currently, `flexible` is assumed as implicit keyword on actor fields if no keyword is declared. +However, we should revise this design, as it may lead to accidental loss of data on upgrade if programmers accidentally forgot to specify `stable`. +In other languages of orthogonal persistence, pointers are by default persistent, analogous to `stable` in Motoko. (Note: One possible future use case might be to mark private methods as stable, which would be a requisite that they can be handed out as capabilities, because such methods must also remain backwards compatible.) @@ -122,7 +124,7 @@ Question: Should the stable signature become a superset of Candid signatures, i. Like the Candid IDL, the Motoko compiler can produce stable signatures for the actors it compiles. -We will also need a tool (the compiler, or a separate one?) that can compare stable signature and verify that an extension is valid according to the Motoko subtyping rules. +By using `moc --stable-compatible`, one can compare stable signature and verify that an extension is valid according to the Motoko subtyping rules. To make that test reliable, the stable signature of an actor should be contained in the Wasm module of a deployed Motoko actor. That way, it is ensured that accurate signature information is always available for each installed actor. @@ -130,19 +132,16 @@ One way to store it would be in a Motoko-specific custom section; another alternative is as a separate internal asset. In either case, it is probably sufficient to use a textual representation. -Like for the IDL, the System would need to provide a way to extract this information from an on-chain canister. +Like for the IDL, the System would need to provide a way to extract this information from an onchain canister. +For even higher safety, [enhanced orthogonal persistence](OrthogonalPersistence.md) integrates the compatibility check in the runtime system, +such that it is atomically guarded and cannot be bypassed e.g. by skipping a `dfx` stable compatibility warning. ## Upgrade Hooks The System API provides a number of hooks that a canister can implement. In particular, this includes the pre & post upgrade hooks. - -Motoko does not currently provide a way to define these hooks. -While the post upgrade hook can be exploited by using expression declarations (see above), there is no immediate way to define the pre upgrade hook. - -Note: This feature could potentially be deferred until later. - +Motoko allows to define custom pre-/post upgrade hooks, see below. ### Syntax @@ -180,13 +179,6 @@ Note: The post-upgrade method differs from expression declarations in the body o ## Implementation -Until Wasm provides multiple memories, the values of stable variables need to be written to the _stable memory_ provided by the System API. -There are multiple possible implementation strategies for this: - -1. Lazy de/serialisation: the compiler generates a pre_upgrade hook that serialises a map of all stable variables to the stable memory, and a post_upgrade hook that deserialises. - -2. Eager de/serialisation: reading/writing a stable variable de/serialises their value directly into a key/value store living in the stable memory. -Dealing with in-place update on mutable components requires indirections in the store via some extensible table. -It also necessitates some form of garbage collection of the stable heap. - -3. Possibly other, like more smarter incremental approaches... +Different [persistence modes](OrthogonalPersistence.md): +* [Enhanced orthogonal persistence](OrthogonalPersistence.md). +* [Classical orthogonal persistence](OldStableMemory.md). diff --git a/design/StableMemory.md b/design/StableMemory.md index d9ddfdeccb6..759ba39390d 100644 --- a/design/StableMemory.md +++ b/design/StableMemory.md @@ -1,24 +1,3 @@ -# Stable Memory API - -The current implementation of stable variables is based on -serialization and deserialization of all stable data on upgrade. This -clearly doesn't scale to large amounts of stable data as there may not -be enough cycles to perform (de)serialization. - -To avoid this upgrade hazard, some canisters with low-level API -access, and large stable memory footprints, arrange to store their -persistent data in stable memory at all times, using either a custom -binary encoding or a mixture of candid and raw binary. - -To provide more fine-grained access to stable memory we propose -extending the existing stable variable implementation with an orthogonal, -library providing (almost) direct access to the IC Stable Memory API. - -Since the implementation of stable variables itself makes temporary use of -stable memory, some coordination between these two alternative, co-existing -interfaces to IC stable memory is required. - - # The IC's Stable Memory API The IC provides a very small set of functions for operating on stable memory: @@ -42,249 +21,10 @@ Note that, in this API, the client is responsible for growing (both stable and wasm) memory before access by read or write (out-of-bounds access will trap). -# A minimal Stable Memory API - -The minimal Motoko prims could be: - -``` -module StableMemory { - size : () -> (logical_page_count : i32); // <= ic0.stable_size() - grow : () -> (new_pages : i32) -> (old_logical_page_count : i32); - loadNat8 : (offset : Nat32) -> Nat8; - // traps outside logical address space - storeNat8 : (offset : Nat32, n : Nat8) -> (); - // traps outside logical address space - ... - loadBlob : (offset : Nat32, size : Nat) -> Blob - // read Blob contents from memory at [offset,..,offset+size-1] into fresh blob, trapping if exceeding logical address space - storeBlob : (offset : Nat32, b : Blob) -> (); // write contents of blob to memory, trapping if exceeding logical address space -} -``` - -NOTE: Motoko's `Nat32` value are always boxed - it might be more efficient to use `Nat` which is unboxed for 30(?)-bit values. - - -``` -fun loadNat8(offset, b) = - assert (offset < StableMemory.size() * wasm_page_size); - mem[offset] - -fun storeNat8(offset, b) = - assert (offset < StableMemory.size() * wasm_page_size); - mem[offset] := b - -``` - -(To avoid overflow on the rhs, we could implement the check as `assert ((offset >> 16) < StableMemory.size())`.) - -On top of this basic API, users should be able to build more -interesting higher-level APIs for pickling user-defined data. - -REMARK: - -Actually implementing the sketched assignments using the existing IC -API involves writing the contents to memory and then copying stable -memory - even for individual words - this could be optimized by an -improved system API offering direct load and stores from/to the stack: - -``` -ic0.stable_write_i32 : (offset : i32, val: i32) -> (); // * -ic0.stable_read_i32 : (offset : i32, size : i32) -> i32; // * -// similarly for i64, f32, f64 -``` - -## Bikeshedding: - -It might be preferable to arrange the API by type, with one nested -module per type: - -``` -module StableMemory { - Nat8 : module { - load : (offset : Nat32) -> Nat8; - store : (offset : Nat32, n : Nat8) -> (); - }; - Nat16 : module { - load : (offset : Nat32) -> Nat16; - store : (offset : Nat32, n : Nat16) -> (); - }; - // uniformly for all scalar prim types. - ... - Blob : module { - read: (offset : Nat32, size : i32) -> Blob - write : (offset : Nat32, b : Blob) -> (); - } -} -``` - -(I think the compiler will still optimize these nested calls to known -function calls, but it would be worth checking). - -# Maintaining existing Stable Variables. - -Stable memory is currently hidden behind the abstraction of stable -variables, which we will still need to maintain. The current -implementation of stable variables stores all variables as a -Candidish record of _stable_ fields, starting at stable memory address 0 with -initial word encoding size (in bytes?) followed by contents. -(Candidish is the Motoko extension of Candid to support mutable data.) - -Starting from a clean slate, we would extend this so all user-defined StableMemory is -stored at a low address, with _stable variable_ data stored just -beyond the currently used StableMemory content on canister_pre_upgrade -and canister_post_upgrade. That way the StableMemory area need not -move, with stable variables simply serialized and appended in -`canister_pre_upgrade` and deserialized and discarded in -`canister_post_upgrade`, leaving the manual StableMemory unchanged. - -For backwards compatibility reasons, we can't do that. - -Luckily, stable variables always require non-zero bytes to encode, so we -can devise a backwards compatible scheme for upgrading -from pre-StableMemory canisters to post-StableMemory -canisters, as follows. - -During execution, abstract stable memory (StableMemory) is aligned -with IC stable memory, at address 0, for reasonable efficiency (apart -from bound checks against logical `size()`). - -During upgrade, if StableMemory has zero pages, we use the existing format, writing -(non_zero) length and content of any stable variables from address 0 or leaving ic0.stable_mem() -at zero with no pages allocated (if there are no stable variables). -Otherwise, we compute the length and data of the stable variable encoding; -save the first word of StableMemory at a known offset from the end of stable memory; -write a 0x00 marker to the first word; and append length (even if zero) and -data (if any) to the end of StableMem. -The logical size of StableMemory and a version number are also written at -known offsets from the end of StableMemory. - -In post_upgrade, we reverse this process to recover the size of StableMemory, -restore the displaced first word of StableMemory and deserialize any stable vars, -taking care to zero the (logically) free StableMemory occupied by any encoded stable variables -and other metadata (so that initial reads after growing beyond page `size` always return 0). - -This scheme avoids relocating most of StableMem and is constant time when -there are no stable variables. - -# Details: - -Stable memory layout (during execution): - -* aligned with stable-memory, with global word `size` holding logical page count (initially 0 < !size < 2^16). -* user are responsible for allocating logical pages. -* each load/store does a `size`-related bounds check. - -During execution, stable variables aren't maintained in stable memory - they are on the Motoko heap. - -Stable memory layout (between upgrades), assuming stable variable encoding `v == {fs:vs}`, a record value of record type {fs:Ts}. - -NOTE: A program with no stable variables still writes an empty record value `v = {}`. - -``` -(case !size == 0) // hence N = 0 - [0..3] StableVariable data len - [4..4+len-1] StableVariable data - [4+len-1,..M-1] 0...0 // zero padding -(case !size > 0) -[0..3] 0...0 -[4..N-1] StableMemory bytes -[N..N+3] StableVariable data len -[N+4..(N+4)+len-1] StableVariable data -[(N+4)+len..M-13] 0...0 // zero padding -[M-12..M-9] value N/64Ki = !size -[M-8..M-5] saved StableMemory bytes -[M-4..M-1] version word - -where N = !size * pagesize // logical memory size - M = ic0.stable_size() * pagesize // physical memory size - pagesize = 64Kb (2^16 bytes) -where (len, data) = serialize(v,data) - -``` - -On pre_upgrade - -```ocaml -func stabilise {fs:Ts} v : value = - let len, data = serialize(v) - in - if !size == 0 then - mem[0,..,3] := len - mem[4,...,4+len-1] := data - else - let N = !size * page_size in - // if necessary, grow mem to page including address N + 4 + len + 4 + 4 + 4 - let M = pagesize * ic0.stable_size() in - mem[N,..,N+3] := len - mem[N+4,..,N+4+len-1] := data - mem[M-12..M-9] := !size - men[M-8..M-5] := mem[0,...,3] // save StableMemory bytes 0-3 - mem[0,..,3] := 0..0 // write marker - mem[M-4..M-1] := version -``` -on post_upgrade - -```ocaml -// restores StableMemory (size and memory) and deserializes any stable variables, zeroing their storage -fun destabilize {fs:Ts} : value = - let pages = ic0.stable_size() in - if pages == 0 then - size := 0; - {fs = nulls} - else - let marker = mem[0,..,3] in // read zero or size of stable value - mem[0,..,3] = 0; - let (offset, len) = - if marker == 0x0 then - let M = pages * pagesize in - let ver = mem[M-4,..,M-1] in - mem[M-4,..,M-1] := 0; - if (ver > version) assert false - mem[0,..,3] = mem[M-8,..,M-5]; // restore StableMemory bytes 0-3 - size := mem[M-12,..,M-9]; - mem[M-12,..,M-9] := 0; - N = size * pagesize; - let len = mem[N,..,N+3] in - mem[N,..,N+3] := 0; - assert len > 0 - assert (N+4+len-1 <= ic0.stable_size() * pagesize) - (N+4, len) - else - (4, marker) - in - assert (0 < len <= ic0.stable_size() * pagesize) - let v = deserialise(offset, len) in - mem[offset,..,offset+len-1] := 0 // clear serialization memory - v -``` - -We explicitly clear memory used by stable variables so StableMem -doesn't need to clear memory when grabbing logical pages from already -existing physical ones. - - -NOTE: We still need to do some work during updgrade and postupgrade, -but if stable variables and user-defined pre/post upgrade hooks are -avoided, then the work is minimal and highly unlikely to exhaust cycle -budget. - -REMARK: - -* An actor that has no stable variables and allocates no StableMem - should require no physical stable memory +# Stable Memory Accesses -* An actor that has n > 0 pages of StableMem will (unfortunately) - require at least n+1 pages of physical memory since we need at least - one extra bit to encode the presence or absence of stable variables - (there is no other preserved state that could record this bit). +Direct stable memory accesses (`ExperimentalStableMemory` in Motoko's base library) has been deprecated. +Instead, [stable regions](StableRegions.md) are available to explicitly access stable memory. -FURTHER CONSIDERATIONS: It would be nice if there was some way to -allow a Motoko actor (perhaps intended to upgrade from a foreign -canister with foreign stable memory format) to have unadulterated, -full-speed access to stable memory, without the protocol required by -the possibility of stable variables. Perhaps we could special case -programs that have *no* stable variables to support this raw -semantics. I.e. if the program declares no stable variables, we -install and upgrade by simply setting `(StableMemory.)size := -ic0.stable_size()`, never consulting or altering physical memory and -(ideally) omitting the additional bounds checking. +However, generally, programmers do not need to use stable memory due to the support of orthogonal persistence, +see [Enhanced Orthogonal Persistence](OrthogonalPersistence.md). diff --git a/design/StableRegions.md b/design/StableRegions.md new file mode 100644 index 00000000000..b3fe0cc709d --- /dev/null +++ b/design/StableRegions.md @@ -0,0 +1,337 @@ +# Stable Region API + +See StableMemory.md for context of the current experimental API. + +This document aims to specify the API and memory representations for a generalization +of this API that permits multiple isolated _regions_ of stable memory, where each can be +grown independently. + +The **region manager** is the state and logic to support this generalization. + + +## Role for "stable regions" in Motoko + +The current stable memory module in `base` has been "experimental" for a long time, and requires a more composable API to graduate from this status. + +Stable regions address the problem that the deprecated `ExperimentalStableMemory` module only provided a single, monolithic memory that makes it unsuitable for directly building composable software parts. + +Stable regions permit a new API that supports composable use cases. + +Stable regions also bring Motoko closer to parity with Rust canister development support today, by giving a run-time-system-based analog of a special Rust library for stable data structures that allocates “pages” for them from stable memory in separate, isolated, memory regions. + + +## Design space + +The design space for the page allocator is defined by at least two +tensions: + + 1. fully-stable representation of allocator meta data **versus** fast load/store operations. + + 2. Total scaling capacity **versus** minimum footprint for meta data. + + +**Tension 1** is introduced because we want to avoid relying on the Motoko heap as the "ground truth" about the allocator's state. If this heap is lost, as it is during an upgrade, then a developer may still want to recover all of the regions' data and meta data. + +Tension 1 is resolved by storing the ground truth in stable memory, keeping it in sync with heap structures that permit faster access operations. + +Compared with the Rust version, we store enough extra meta data to permit: + + - Regions whose page blocks are in arbitrary order, not + necessarily in order of smallest to highest address. + + - 2^64-1 Regions max (instead of 255 Regions max). + Due to the limit on blocks, only 2^16-1 can have non-zero page size. + +We want to permit arbitrary page block orders to make a smooth +transition to region reclamation and re-allocation in the near +future, with potential integration into the Motoko GC. The +extra complexity is modest, and seems "worth" the cost. + +We change the maximum region limit because 255 may be too small in +some extreme cases and incompatible with GC. +Instead, we can freely allocate new regions, recycling blocks, but not +Region ids. The id of a Region is invariant and will not change, even with GC. + +We address the question of whether the new limit of 32k regions is +"enough" in the Q&A section (it is, for all practical purposes) + + +**Tension 2** is introduced because we want a design that will continue +to work even when canisters can store more stable data than today (32GB). + +Tension 2 is resolved by making prudent representation choices. + +The representations we choose for regions and region identifiers +permit a scaling to 256GB of stable data while still permitting meta +data to be repeated in both stable and non-stable arenas. These are +the same limits imposed by the Rust implementation, for the same +reasons. See Q&A for more discussion. + + +## Definitions and constants + + - a **page** is 65536 bytes. + - a **page block** is a contiguous sequence of 128 pages (~8MB). + - a **page block index** is a 16 bit, index-based identifier for a page block. + - a **region** is a sequence of (generally non-contiguous) **page blocks**. + - the maximum number of page blocks is 32768. + - the maximum amount of stable memory for all regions is 256GB. + + +## Questions and answers + +### Q: What determines the 8MB non-empty region minimum? + +Mostly, we want to reduce the amount of metadata we need to track, so instead of per-page metadata (lots) we only need per-block metadata (less). +This size means we grow a region by more than one physical page at +a time (in terms of the way that the canister interacts with the +system API, at least). Rather than actually grow by a single page, +the implementation grows by a "page block" (8MB) at a time. + +This choice means that there are 128 pages per page block, and that +the maximum number of regions and region blocks are each relatively +small (32k each). Consequently, they can each be identified with a +2-byte identifier, and we can pre-allocate tables to store certain +relations about them, which is critical. + +### Q: Are 32767 regions enough? + +A: Permitting more than 32k regions may seem theoretically +interesting, but is not practical given other parameters today that +control the minimal footprint of a region (8MB) and dictate the +maximum size of stable memory for a canister today (32GB). With 32k +regions at 8MB each, well over the maximum stable memory size is used +(256GB compared to 32GB, the limit today) + +### Q: When is stable memory becoming less costly? + +Spring 2023. + +### Q: How does the cheaper stable memory access cost compare with ordinary heap memory access cost? + +2-3x slower than ordinary heap memory. + + +## Design details + +### API + +Internal region allocator operations: + + - `initialize` -- called by the RTS, not by the Motoko developer. + +User-facing region allocator operations: + + - `region_new` -- create a dynamic region. + - `region_grow` -- grow region by a specified number of pages. + - `region_load` -- read some data from the region. + - `region_store` -- store some data into the region. + +### FUTURE WORK + +Add a special operation, for testing our design for future GC integration (bonus): + +- `region_release` -- release region and reuse region's page blocks. + +The `_release` operation is *not* part of the user-facing API nor part of the MVP, +but supporting it is important because it means we can transition quickly to an integration +with the ambient Motoko GC if we can support it. + +Another special operation, for disaster recovery: + + - `rebuild` -- not needed unless we need to recreate all Region objects from their stable-memory counterparts. + + +## Internal footprint + +The state of the allocator is stored in a combination of: + + - stable memory fields and tables and + - stable heap memory, in the form of objects of opaque type `Region`. + +The stable memory state is sufficient to reconstitute the stable heap objects +(`rebuild` operation, described in a subsection below). + +That means that even if the stable parts of the heap are lost, the +stable memory state can fully describe the region objects that will be rebuilt when it succeeds. + +### stable memory fields + + - total allocated blocks, `u16`, max value is `32768`. + - total allocated regions, `u64`, max value is 2^64-1 (one region is reserved for "no region" in block-region table). + - The `block` table (fixed size, about 6 pages). + +### representation of values of type `Region` + + - A singleton, heap-allocated object with mutable fields. + - While being heap-allocated, the object is also `stable` (can be stored in a `stable var`, etc). + - `RegionObject { id_lower: u32, id_upper: u32; mut page_count: u32; mut vec_pages: Value }` + - Fields id_lower (lower 32-bits) and id_upper (upper 32-bits) gives the Region's numerical 64-bit (id = (id_upper \<\< 32 | id_lower)). + - Field `page_count` gives the number of pages allocated to the Region. + - Field `vec_pages` points at a heap-allocated `Blob` value, and it works with `page_count` + to represent a growable vector that we call the region's **"access + vector"** (because "blocks vector" sounds a bit strange, and its + used to support O(1) access operations): + - the access vector has `vec_capacity` slots. + - each slot is a `u16`. + - the first `page_count + 127 / 128` slots contain a valid page block ID for the region. + - during an upgrade, the access vectors get serialized and deserialized as data `Blobs`. + + +### region-blocks relation + +The `region-blocks` relation is not materialized into a table in stable memory (doing so with a pre-allocated table would be prohibitively large). + +Instead, this relation is represented in two ways at the same time: + 1. by the set of heap-allocated region objects, and their access vectors. The access vectors provide O(1) store and load support. + 2. by the `block-region` table, which together are sufficient to recreate all of the heap-allocated region objects. + +In ordinary operation, the second feature is not required. In the event of an upgrade failure, however, it could be vital (See `rebuild`). + +### block-region table + + - purpose: + - relate a block ID ("page block ID") to its region (if any), its position (or rank) in that region (see `rebuild`) and its current size in (used) pages (`<=128`). + All but the last block owned by a region should have all pages 128 allocated. + + - NB: The organization of this table is not useful for efficient + access calculations of load or store (they require a linear + search that would be prohibitively slow). OTOH, this + table is suitable to do a "batch" rebuild of the dynamic heap-allocated vectors + in that table, if need be (see `rebuild`). + + - 32768 entries (statically sized). + - 8 (id) +2 (rank) + 1 (used) = 11 bytes per entry. + - entry type = `BlockRegion { region : u64, position : u16, size: u8 }` + - the location of each entry gives its corresponding block ID. + + +### Overview of `rebuild` + +When upgrades work as expected, stable `Regions` are serialized and deserialized just like other stable data. + +For disaster recovery, we can **also** rebuild all of the region objects from data in stable memory. + +We use the `block-region` tables in stable memory to rebuild the regions' objects: + + - The `block-region` table gives a relative position and region ID for each block ID together with utilized page count. + +Once each regions' vectors have been sized (by a linear scan of block-region, summing block sizes) and allocated, the block-region table says how to fill them, one entry at a time. +Unlike the Rust design, vector entries can be populated out-of-order. + +Currently, we need only recover region 0 (when upgrading). + + +### Special (reserved) regions + + - Region 0 -- Anonymous region, for supporting the legacy API that we have today, which lacks `Region` values. + - Region 1 -- "Reclaimed blocks" region that consists of blocks reclaimed from GC'd regions. + - Regions 2-15 -- Future use by Motoko RTS (TBD). + +### Overview of GC support (future work) + +- Regions are represented (see special subsection) with heap objects that are `stable`, but mutable. +- They have special GC headers to recognize their special structure. +- The block-region table (or a more transient bitmap) keeps track of which blocks are in use as Region heap values are GC'd. + +Blocks can be marked during normal GC, with unmarked blocks returned to a transient free-list. In this design, blocks are recycled during +the lifetime of a single canister version. + +Alternatively, Blocks can be marked only during deserialization after an upgrade, for bespoke, Region-only, GC during upgrades, with unmarked blocks +returned to a free list. +In this design, blocks are only recycled during upgrade from one version to the next, meaning long-lived canisters that create garbage regions will leak +space. + +### Migration from earlier designs into region system + +#### Version overview + +Including this design, there are three possible verions (`0`, `1`, or `2`): + + 0. Stable vars only. + 1. Stable vars *plus* direct access to IC0 API, including `grow`. + This access is exposed via the Experimental Stable Memory API. + 2. This Region system, where direct access still works through region zero. + + +#### Key points + +- Version 0: + - will never be forced to "migrate" to other versions (assuming no stable memory API use). + - will never incur the space overhead of the region system. + +- Migration from 0 to version 1 occurs when: + - Experimental Stable Memory function `grow` is invoked for the first time. + This will not incur the space overhead of the region system. + +- Migration from version 0 or version 1 to version 2 occurs when: + - An initial region is allocated via `Region.new`. + This will incur the space overhead of the region system. + The space overhead is 16 pages (1MB) when migration from version 0, and 128 pages (8MiB) when migrating from version 1. + +#### Compiler flag + +Compiler flag + +``` + --stable-regions +``` + +Affects upgrades only and forces migration directly into version 2 from version 0 or 1. +It is provided for testing purposes and *not* required for use of regions. + +#### Format version details + +The first 32 bits of stable memory record a "marker," which indicates how to determine the "version number" +for Motoko stable memory. This version number is stored either: + - *implicitly*, when the marker is non-zero, and version is `0`. + - *explicitly*, when the marker is zero, and version is stored elsewhere (but currently always `1`). + +Including this design, there are three possible verions (`0`, `1`, or `2`). See preceeding section. + +In the first cases (`0`) and (`1`), we wish to *selectively* migrate into the region system (`2`), with its own internal versioning. + + +#### Opt-in mechanism + +The opt-in mechanism for using version 2 consists of using: + + - dynamically calling `Region.new()` form a canister currently in version 0 or 1; + - staticly specifying compiler flag `--stable-regions`. This is mostly useful for testing. + +Critically, + +1. The use of physical stable memory is pay-as-you-go: canisters that do not use regions do not pay for that priviledge. +2. There is no provision for "downgrading" back to earlier, pre-region systems. + +##### Version 0 migration. + +To migrate from version 0 to version 2, there is nothing additional to do for existing data. + +The region system detects this case by measuring the zero-sized stable memory during its initialization and +starts allocating blocks from address 16*2^16 (1MiB overhead), leaving 10 pages unused for future use. + +##### Version 1 migration. + +Migrating version 1 stable memory renames it as "region 0" in Version 2. + +Critically, to migrate from version 1, we must perserve existing data, but reorganize it slightly. + +In effect, all existing data will retain its logical order as (pre-allocated) region 0. + +To accomodate the meta data of the region system, we move the first block of region 0, physically. + +Then, we reformat the first block of stable memory as the region meta data block. + +The rest of the blocks become part of region 0, with its first block stored at the end of physical memory. + +The region system starts allocating blocks from address 128*2^16 (8MiB overhead), leaving 122 pages unused for future use. + +Since we do not move the remaining blocks of region 0, the first block of memory (excluding meta-data) is unused space. + +This design ensures that an existing canister using very large amounts of experimental stable memory can be migrated with only constant-cost movement +of the first block (128 pages) of memory. + +## Orthogonal Persistence + +Stable regions can be used together with orthogonal persistence, see [Classical Persistence](OldStableMemory.md) and [Enhanced Orthogonal Persistence](OrthogonalPersistence.md). \ No newline at end of file diff --git a/design/WhitePaper.md b/design/WhitePaper.md index de94bff1411..695018dbf7d 100644 --- a/design/WhitePaper.md +++ b/design/WhitePaper.md @@ -56,7 +56,7 @@ Oftentimes, these goals are difficult to achieve fully or can be in conflict wit * *Modules.* Motoko also features a simple module system, where modules are essentially a restricted form of object that must be stateless. Modules can contain type definitions, but not (currently) abstract them, i.e., hide their implementation. A Motoko compilation unit is either a module, or a top-level actor or actor class definition that can be imported as if it was contained in a module. -* *Canonical type system.* Motoko's type system, at its core, is a fairly canonical typed lambda calculus with primitive types, labeled products and sums (i.e., objects and variants), first-class function types, polymorphism (i.e., generics), and structural recursive subtyping with top and bottom types. Type theory experts will recognise the close similarity to (Kernel) System F<:. Type checking mostly follows a strict bidirectional discipline, with only a few exceptions regarding optional inference of polymorphic type instantiation, overloaded operators, and multiple passes to account for recursive declarations. +* *Canonical type system.* Motoko's type system, at its core, is a fairly canonical typed lambda calculus with primitive types, labeled products and sums (i.e., objects and variants), first-class function types, polymorphism (i.e., generics), and structural recursive subtyping with top and bottom types. Type theory experts will recognise the close similarity to (Kernel) System F\<:. Type checking mostly follows a strict bidirectional discipline, with only a few exceptions regarding optional inference of polymorphic type instantiation, overloaded operators, and multiple passes to account for recursive declarations. * *Shared types.* Motoko distinguishes a subset of types that are "sharable". These are those types whose values can be serialised, compared, or otherwise be inspected transparently. They include primitive types, immutable aggregates (arrays, objects, variants) whose components are shared, and references to actors or shared functions. @@ -370,7 +370,7 @@ becomes ``` Result.chain(g(1), func(x) { - Result.chain(g(2), + Result.chain(g(2), func(y) { Result.make(f(x, y)) } @@ -413,9 +413,9 @@ The relation `<:infer` infers the rhs type substitution, as for implict type arg Challenge: One issue with the above is that `T1` does not generally determine all type parameters of `chain`, particularly the ones only occurring in the result type `T'`. It may be necessary to type-check `exp!` in analysis mode, though that could be inconvenient. -#### Bindings in `or`-Patterns +#### Bindings in `or`-Patterns ([#3807](https://github.com/dfinity/motoko/pull/3807)) -Currently, when using `or`-patterns, it is not possible to bind a variable in the alternatives. In other languages, this is usually allowed, and is useful. +When using `or`-patterns, it is possible to bind a variable in the alternatives. This is useful to avoid `case` repetitions: ``` func free(x : Text, e : exp) : Nat { switch e { @@ -621,14 +621,8 @@ Note: the obvious "solution", namely storing closure environments inside the ori #### Upgrades and Memory -The most difficult problem to solve in the programming model of the IC by far is the question of safe and robust upgrades. Motoko currently uses the IC's _stable memory_ API to serialise the entire heap of an actor into stable memory before an upgrade, and restore it afterwards. The crucial point of this is that the serialised format is fixed and not dependent on the compiler version. Consequently, it is perfectly fine if the new version of the actor has been compiled with a different (typically newer) compiler version that potentially uses a differen memory layout internally (e.g., a new garbage collector). - -The drawback is that this serialisation/deserialisation step is expensive. Worse, it may even run out of cycles. - -There are multiple ways in which the representation of stable variables could be improved to avoid this overhead (or rather, trade it off against a different overhead). However, most of them would be extremely costly with the IC's stable memory API. This API was merely a stop-gap measure while we wait for the IC to support the upcoming Wasm proposal for accessing multiple memories. Once this becomes available, it would unlock a number of new and better implementation options. - -Yet, representing all persistent data in terms of serialised Motoko values might never be enough for all use cases. Imagine, for example, emulating a file system or a high-performance data base as persistent storage. For these use cases, Motoko will provide a low-level interface that enables direct access to raw stable memory, leaving it up to respective libraries to build suitable high-level abstraction on top. - +The most difficult problem to solve in the programming model of the IC by far is the question of safe and robust upgrades. +For this purpose, Motoko implements powerful and safe persistence, see [Enhanced Orthogonal Persistence](OrthogonalPersistence.md). #### Upgrades and Methods @@ -669,14 +663,16 @@ The ability to link compiled modules together would also be a first step towards Unfortunately, though, this is a more difficult problem than linking modules compiled in the same language, since the data types, memory management, and calling conventions used by different languages are rarely compatible. Supporting cross-language calls requires a suitable ABI agreed upon by different Wasm compilers, which in turn requires some kind of standard. There is work on a proposal ([interface types](https://github.com/WebAssembly/interface-types/blob/main/proposals/interface-types/Explainer.md)) for Wasm that could be the basis of such a mechanism, but it's not ready yet. +Wasm component model offers a solution for secure intra-canister language interop on the IC. + -#### On-chain Linking +#### Onchain Linking [Separate compilation](#separate-compilation) avoids the need to _compile_ applications in a monolitic manner, but it does not prevent the need to _deploy_ them in monolithic form. No matter how large an application and how small a change, upgrading always requires redeploying the entire code. -Also, it is not possible to share modules on-chain between multiple applications. For features like [unicode support](#text), it would be desirable if respective modules of the language runtime would only have to be installed on the chain once and could be shared between applications. +Also, it is not possible to share modules onchain between multiple applications. For features like [unicode support](#text), it would be desirable if respective modules of the language runtime would only have to be installed on the chain once and could be shared between applications. -Supporting this would require a new mechanism in the IC that allows canisters to consist of more than just a single Wasm module, and linking these modules _dynamically_, "on-chain", reminiscent of dynamic linking in conventional operating systems. Unfortunately, there currently isn't any mechanism planned for the IC to support that. +Supporting this would require a new mechanism in the IC that allows canisters to consist of more than just a single Wasm module, and linking these modules _dynamically_, "onchain", reminiscent of dynamic linking in conventional operating systems. Unfortunately, there currently isn't any mechanism planned for the IC to support that. ### Platform Support diff --git a/design/scoped-await.md b/design/scoped-await.md index 6bc0ed30c88..d4773c30213 100644 --- a/design/scoped-await.md +++ b/design/scoped-await.md @@ -361,7 +361,7 @@ is rejected because, once annotated: } ``` -since `$1 <> $` and `$2` <> `$`. +since `$1 <> $` and `$2` \<\> `$`. ### Imperative deadlock diff --git a/doc/Makefile b/doc/Makefile index 1a8cfecbcc9..7a95611367d 100644 --- a/doc/Makefile +++ b/doc/Makefile @@ -23,7 +23,7 @@ html: # TODO: perhaps use node and remark-cli to compile out remark plugins first or use docusaurus to build site properly rm -rf html mkdir -p html - for f in md/*.md; do pandoc -f gfm --toc -t html -s --metadata title="$$f" -o html/$$(basename $$f .md).html $$f; done + for f in md/*/*.md; do pandoc -f gfm --toc -t html -s --metadata title="$$f" -o html/$$(basename $$f .md).html $$f; done preview: diff --git a/doc/README.md b/doc/README.md index 458fdc86c59..b1b586785bf 100644 --- a/doc/README.md +++ b/doc/README.md @@ -9,7 +9,7 @@ python3 -m http.server --directory html ``` CI pushes these docs for latest master to -. +[https://hydra.dfinity.systems/job/dfinity-ci-build/motoko/docs/latest/download/1/overview-slides.html](https://hydra.dfinity.systems/job/dfinity-ci-build/motoko/docs/latest/download/1/overview-slides.html). The local documentation is suboptimal and compiled with pandoc, not docusaurus so it doesn't understand or process remark-code-import file includes, diff --git a/doc/md/about-this-guide.md b/doc/attic/about-this-guide.md similarity index 96% rename from doc/md/about-this-guide.md rename to doc/attic/about-this-guide.md index 25808984761..c68e63d290a 100644 --- a/doc/md/about-this-guide.md +++ b/doc/attic/about-this-guide.md @@ -52,7 +52,7 @@ For transparency into the principles that guide the engineering effort, the engi The following guiding principles represent the core values of the engineering organization in prioritized order: -1. Seamless integration with the [Internet Computer blockchain network](../../concepts/what-is-IC.md#what-is-the-internet-computer) to ensure that Motoko provides full language support for the actor-based model, asynchronous messaging, data persistence, interface description language interoperability, and other features. +1. Seamless integration with the Internet Computer blockchain network to ensure that Motoko provides full language support for the actor-based model, asynchronous messaging, data persistence, interface description language interoperability, and other features. 2. Ergonomics to ensure that Motoko embraces familiarity, simplicity, clarity, explicitness, and other human factors. diff --git a/doc/md/advanced-discussion.md b/doc/attic/advanced-discussion.md similarity index 100% rename from doc/md/advanced-discussion.md rename to doc/attic/advanced-discussion.md diff --git a/doc/md/extrastuff.md b/doc/attic/extrastuff.md similarity index 100% rename from doc/md/extrastuff.md rename to doc/attic/extrastuff.md diff --git a/doc/attic/overview.md b/doc/attic/overview.md new file mode 100644 index 00000000000..628a65882fa --- /dev/null +++ b/doc/attic/overview.md @@ -0,0 +1,1037 @@ +# Concise overview of Motoko + +This is terse, slide-like introduction to Motoko and its features. + +(For a gentler introduction, visit the other sections on this site.) + +## Motivation and Goals + +A simple, useful language for the Internet Computer (IC) + +- Familiar syntax + +- Safe by default + +- Incorporating **actor** model for canister smart contracts + +- Seamless integration of Internet Computer features + +- Making most of present and future WebAssembly + +## Key Design Points + +- Object-oriented, functional & imperative + +- Objects as records of functions + +- `async`/`await` for sequential programming of asynchronous messaging + +- Structural typing with simple generics and subtyping + +- Safe arithmetic (both unbounded and checked) + +- Non-nullable types by default + +- Garbage collected (no manual memory management) + +- JavaScript-like syntax but statically typed & sane + +Inspirations: Java, JavaScript, C#, Swift, Pony, ML, Haskell + +## Semantics + +- call-by-value (like Java, C, JS, ML; unlike Haskell) + +- declarations are locally mutually recursive + +- parametric, bounded polymorphism + +- subtyping as zero-cost subsumption, not coercion + +- no dynamic casts + +- no inheritance + +## Implementation(s) + +- implemented in OCaml (leverages `wasm` libary) + +- simple reference interpreter + +- less simple compiler to WebAssembly + + - multipass with typed IR in each pass. + + - uniform representation, unboxed arithmetic + + - copying GC, compacting GC, or generational GC + (select which with compiler flag) + + - GC invoked after messages (for now) + +- polymorphism by erasure + +# The language + +## Expressions + +- Identifiers: + `x`, `foo_bar`, `test123`, `List`, `Map` + +- Parentheses `( … )` for grouping + +- Braces `{ … }` for scoping (and records) + +- `;` for sequencing + +- Type annotations (to help type inference): + `(42 : Int)` + (zero cost) + +## Libraries + +``` motoko name=impDebugInt +import Debug "mo:base/Debug"; +import Int "mo:base/Int"; +``` + +(`import MyLib "src/MyLib"` imports a library from the local file system.) + +Specific bindings can be imported from the module using object patterns + +``` motoko +import { push; nil } = "mo:base/List"; +``` + +## Libraries continued + +``` motoko +import Debug "mo:base/Debug"; +import Int "mo:base/Int"; +import Trie "mo:base/Trie"; + +type Users = Trie.Trie; // reference types + +Debug.print(Int.toText(7)); // reference functions/values +``` + +## Blocks and declarations + +``` motoko include=impDebugInt +type Delta = Nat; +func print() { + Debug.print(Int.toText(counter)); +}; +let d : Delta = 42; +var counter = 1; +counter := counter + d; +print(); +``` + +- Semicolon after each declaration! + +- Mutually recursive + +- Mutable variables marked explicitly + +## Control flow + +The usual suspects…​ + +- `do { … }` + +- `if b …` + +- `if b … else …` + +- `switch e { case pat1 e1; …; case _ en }` + +- `while b …` + +- `loop …` + +- `loop … while b` + +- `for (pat in e) …` + +- `return`, `return e` + +- `label l e`, `break l e` + +- `do ? { … e! … }` + +- `async e`, `await e` *(restricted)* + +- `throw`, `try … catch x { … }` *(restricted)* + +# Primitive types + +## Unbounded integers + +`Int` + +`{ …​, -2, 1, 0, 1, 2, …​ }` + +Inferred by default for negative literals. + +Literals: `13`, `0xf4`, `-20`, `+1`, `1_000_000` + +## Unbounded naturals + +[`Nat`](../base/Nat.md) + +`{ 0, 1, 2, …​ }` + +Non-negative, trap on underflow. + +Inferred by default for non-negative literals + +Literals: `13`, `0xf4`, `1_000_000` + +`Nat <: Int` + +[`Nat`](../base/Nat.md) is a *subtype* of `Int` + +(you can supply a [`Nat`](../base/Nat.md) wherever an `Int` is expected) + +## Bounded numbers (trapping) + +`Nat8`, `Nat16`, `Nat32`, `Nat64`, `Int8`, `Int16`, `Int32`, `Int64` + +Trap on over- and underflow; wrap-around and bit-manipulating operations available separately + +Needs type annotations (somewhere) + +Literals: `13`, `0xf4`, `-20`, `1_000_000` + +## Floating point numbers + +`Float` + +IEEE 754 double precision (64 bit) semantics, normalized NaN + +Inferred for fractional literals + +Literals: 0, -10, `2.71`, `-0.3e+15`, `3.141_592_653_589_793_12` + +## Numeric operations + +No surprises here + +`- x` +`a + b` +`a % b` +`a & b` +`a << b` +… + +`a +% b, a -% b, …` for wrapping, modular arithmetic (where appropriate) + +## Characters and Text + +`Char`, `Text` + +Unicode! Character = Unicode scalar value; no random access on text + +- `'x'`, `'\u{6a}'`, `'☃'`, + +- `"boo"`, `"foo \u{62}ar ☃"` + +- `"Concat" # "enation"` + +## Booleans + +`Bool` + +Literals: `true`, `false` + +`a or b` +`a and b` +`not b` +`if (b) e1 else e2` + +# Functions + +## Function types + +- Simple functions: + + ``` motoko no-repl + Int.toText : Int -> Text + ``` + +- multiple arguments and return values + + ``` motoko no-repl + divRem : (Int, Int) -> (Int, Int) + ``` + +- can be generic/polymorphic + + ``` motoko no-repl + Option.unwrapOr : (?T, default : T) -> T + ``` + +- first-class (can be passed around, stored) + + ``` motoko no-repl + map : (f : A -> B, xs : [A]) -> [B] + let funcs : [(T) -> T] = … + ``` + +## Function Declarations & Use + +``` motoko include=impDebugInt +func add(x : Int, y : Int) : Int = x + y; + +func applyNTimes(n : Int, x : T, f : T -> ()) { + if (n <= 0) return; + f(x); + applyNTimes(n-1, x, f); +}; + +applyNTimes(3, "Hello!", func(x) { Debug.print(x) } ); +``` + +- `func() { … }` short for `func() : () = { … }` + +- Parametric functions + +- Type instantiations may sometimes be omitted + +- Anonymous functions (a.k.a. lambdas) + +# Composite types + +## Tuples + +`(Bool, Float, Text)` + +immutable, heterogeneous, fixed size + +``` motoko name=tuple +let tuple = (true or false, 0.6 * 2.0, "foo" # "bar"); +``` + +``` motoko include=tuple +tuple.1; +``` + +``` motoko include=tuple +let (_,_,t) = tuple; +t +``` + +## Options + +`?Text` + +is either a value of that type, e.g. `?"hello"`, or `null`. + +``` motoko name=display +func display(x : ?Text) : Text { + switch x { + case (null) { "No value" }; + case (?y) { "Value: " # y }; + }; +}; +``` + +``` motoko include=display +(display(null), display(?"Test")) +``` + +## Option blocks + +Switching on every option value can be inconvenient …​ + +The *option block*, `do ? { … }`, allow you to safely access option values with a postfix *null break* `!` expression. + +Within `do ? { … }`, which returns an option, the expression `e!` immediately exits the block with `null` when the value of option `e` is `null` or continues with the option’s contents. + +``` motoko +func add(x : ?Nat, y: ?Nat) : ?Nat { + do ? { x! + y! }; +}; + +(add(null, null), add (?1,null), add (?1,?2), add (null,?2)); +``` + +## Arrays (immutable) + +`[Text]` + +``` motoko include=impDebugInt +let days = [ "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" ]; + +assert(days.size() == 7); + +assert(days[1] == "Tue"); + +// days[7] will trap (fixed size) + +for (d in days.vals()) { Debug.print(d) }; +``` + +## Arrays (mutable) + +`[var Nat]` + +``` motoko +let counters = [var 1, 2, 3]; + +assert(counters.size() == 3); + +counters[1] := counters[1] + 1; + +// counters[3] will trap (fixed size) + +counters; +``` + +## Records + +`{first : Text; last : Text; salary : var Nat}` + +``` motoko include=impDebugInt +let employee = {first = "John"; last = "Doe"; var salary = 81_932}; + +Debug.print( + employee.first # " " # employee.last # " earns " # + Int.toText(employee.salary) # " pounds." +); + +employee.salary += 79_496; + +employee; +``` + +## Objects + +`{first : Text; last : Text; get : () → Nat; add : Nat → ()}` + +``` motoko +object self { + public let first = "John"; + public let last = "Doe"; + var salary : Nat = 81_932; // private by default + public func get() : Nat = salary; + public func add(bump : Nat) { salary += bump }; +} +``` + +## Classes + +``` motoko +class Employee(fst : Text, lst : Text) { + public let first = fst; + public let last = lst; + var salary : Nat = 0; + public func get() : Nat = salary; + public func add(bump : Nat) { salary += bump }; +} +``` + +Classes are factories for constructing objects. +A class introduces a type and a function (for constructing instances). + +Just sugar for: + +``` motoko no-repl +type Employee = {first : Text; last : Text; get : () -> Nat; add : Nat -> ()}; + +func Employee(fst : Text, lst : Text) : Employee = object { … } +``` + +## Variants + +`{#sun; #mon; #tue; #wed; #thu; #fri; #sat}` + +``` motoko +type Day = {#sun; #mon; #tue; #wed; #thu; #fri; #sat}; + +func toText(d : Day) : Text { + switch d { + case (#sun) "Sunday"; + case (#mon) "Monday"; + case (#tue) "Tuesday"; + case (#wed) "Wednesday"; + case (#thu) "Thursday"; + case (#fri) "Friday"; + case (#sat) "Saturday"; + }; +}; + +func sort(d : Day) : { #weekDay; #weekEnd } { + switch d { + case (#sun or #sat) #weekEnd; // or pattern + case _ #weekDay; // wildcard pattern + }; +}; +``` + +## Recursive Types + +``` motoko name=Lists +type List = { + #item : {head : Text; tail : List}; // variant with payload! + #empty // ^^^^ recursion! +}; + +func reverse(l : List) : List { + func rev(l : List, r : List) : List { + switch l { + case (#empty) { r }; + case (#item { head; tail }) { // nested patterns + rev(tail, #item {head; tail = r}) + } + } + }; + rev(l, #empty); +}; + +let l = reverse(#item {head = "A"; tail = #item {head = "B"; tail = #empty}}); +``` + +## Generic types + +``` motoko +type List = { + #item : {head : T; tail : List}; + #empty +}; + +func reverse(l : List) : List { + func rev(l : List, r : List) : List { + switch l { + case (#empty) { r }; + case (#item { head; tail }) { // a nested pattern + rev(tail, #item {head; tail = r}) + } + } + }; + rev(l, #empty); +}; + +let s : List = + reverse(#item {head = "A"; tail = #item {head = "B"; tail = #empty}}); + +let ns : List = + reverse(#item {head = 0; tail = #item {head = 1; tail = #empty}}) +``` + +# Packages and modules + +## Modules + +``` motoko no-repl +// the type of base/Int.mo +module { + type Int = Prim.Types.Int; + toText : Int -> Text; + abs : Int -> Nat; + // ... +} +``` + +modules contain named types and values (like objects), +but are restricted to *static* content (pure, no state, …) + +## Module imports + +``` motoko no-repl +import Debug "mo:base/Debug"; // import from package +import Int "mo:base/Int"; +import MyLib "lib/MyLib"; // import from local file MyLib.mo +``` + +`base` package provides basic features as separate modules. + +More libraries popping up! + +`MyLib.mo` *must* contain a module or actor class, eg: + +``` motoko no-repl +module { + public type List = …; + + public func reverse(l : List) : List { … }; +} +``` + +# Platform features + +## Actor types + +Like object types, but marked as `actor`: + +``` motoko name=actorTypes +type Broadcast = actor { + register : Receiver -> (); + send : Text -> async Nat; +}; + +type Receiver = actor { + recv : query Text -> async Nat +}; +``` + +*sharable* arguments and *no* or *async* result type. + +- `register` is a *oneway* IC method (unawaitable). + +- `send` is an IC *update* method + +- `recv` is IC *query* method + +IC canister with Candid interface ≈ Motoko actor + +## sharable ≈ serializable + +**Sharable:** + +- all primitive types + +- records, tuples, arrays, variants, options + with immutable sharable components + +- `actor` types + +- `shared` function type + +**Not sharable:** + +- mutable things + +- local functions + +- objects (with methods) + +## A complete actor + +``` motoko +import Array "mo:base/Array"; + +actor Broadcast { + type Receiver = actor {recv : query Text -> async Nat}; + + var r : [Receiver] = []; + + public func register(a : Receiver) { + r := Array.append(r, [a]); + }; + + public func send(t : Text) : async Nat { + var sum = 0; + for (a in r.vals()) { + sum += await a.recv(t); + }; + return sum; + }; +} +``` + +a typical actor/canister main file + +## Async/await + +`async T` + +asychronous future or promise + +introduced by `async { … }` +(implicit in async function declaration) + +`await e` +suspends computation pending `e`’s result: +if the result is a value, continues with that value, +if the result is an `Error`, `throw`s the error. + +``` motoko no-repl + public func send(t : Text) : async Nat { + var sum = 0; + for (a in r.vals()) { + sum += await a.recv(t); // may return Nat or `throw` error + }; + return sum; + }; +``` + +(Errors can be handled using `try … catch …`) + +## Concurrency Hazards + +Functions that `await` are *not* atomic. +Suspension introduces *concurrency hazards*. + +A bad implementation of `send`: + +``` motoko no-repl + var sum = 0; // shared state! + public func send(t : Text) : async Nat { + sum := 0; + for (a in r.vals()) { + sum += await a.recv(t); + }; + return sum; + }; +``` + +(Concurrent `send`s will share and clobber `sum`.) + +Beware of race conditions! + +## Actor import + +``` motoko +import Broadcast "canister:Broadcast"; +/* or +import Broadcast "ic:r7inp-6aaaa-aaaaa-aaabq-cai"; +*/ +actor Self { + + var count = 0; + + public func go() { + Broadcast.register(Self); + }; + + public query func recv(msg : Text) : async Nat { + return count; + } +} +``` + +(assumes there is a Candid file describing the interface of the import) + +## A Candid interface file + +`Broadcast`'s Candid file (produced by `moc --idl Broadcast.mo` compiler). + +Broadcast.did: + +``` candid +type Receiver = + service { + recv: (text) -> (nat) query; + }; +service : { + register: (Receiver) -> () oneway; + send: (text) -> (nat); +} +``` + +A language independent interface definition. + +Could just as easily describe a Rust implementation of `Broadcast`. + +## Principal and caller + +``` motoko +import Principal "mo:base/Principal"; + +actor Self { + + public shared(context) func hello() : async Text { + let myself : Principal = Principal.fromActor(Self); + if (context.caller == myself) { + "Talking to yourself is the first sign of madness"; + } else { + "Hello, nice to see you"; + }; + }; + +} +``` + +## Errors + +``` motoko no-repl +import Principal "mo:base/Principal"; +import Error "mo:base/Error"; + +actor Self { + + public shared(context) func hello() : async Text { + let myself : Principal = Principal.fromActor(Self); + if (context.caller == myself) { + throw Error.reject("Talking to yourself is the first sign of madness"); + } else { + "Hello, nice to see you"; + }; + }; + +}; + +async { + let t = try Self.hello() catch (e) { Error.message(e); } +}; +``` + +Similar to exceptions in other languages, +but *only* available in async contexts, e.g. shared functions; async blocks + +## Stable variables + +If we upgrade the `Broadcast` actor, all current registrations are lost. +To preserve them, declare the state variable `r` as `stable`. + +``` motoko no-repl +import Array "mo:base/Array"; + +actor Broadcast { + + type Receiver = actor {recv : query Text -> async Nat}; + + stable var r : [Receiver] = []; // declare r `stable` + + public func register(a : Receiver) { … } + public func send(t : Text) : async Nat { … } + + // optional pre-upgrade action + system func preupgrade() { Debug.print("saving receivers"); } + + // optional post-upgrade action + system func postupgrade() { Debug.print("restoring receivers"); } +} +``` + +stable variables must have *stable* types (see manual) +`system` hooks can’t send messages + +# Type system + +## Structural + +``` motoko include=Lists +/* +type List = { + #item : {head : Text; tail : List}; + #empty +}; + +func reverse(l : List) : List { //... }; +*/ +type Stack = { + #empty; + #item : {tail : Stack; head : Text}; +}; + +let stack : Stack = #empty; + +let revStack = reverse(stack); // works though reverse defined on List (not Stack) +``` + +Type definitions +do not create types, +but name existing types + +Despite their different names, `Stack` and `List` are equivalent types. + +## Subtyping (Variants) + +`WeekDay <: Day` + +``` motoko +type WeekDay = {#mon; #tue; #wed; #thu; #fri}; + +type Day = {#sun; #mon; #tue; #wed; #thu; #fri; #sat}; + +func toText(d : Day) : Text { + switch d + { case (#sun) "Sunday"; + case (#mon) "Monday"; + //... + }; +}; + +let mon : WeekDay = #mon; +let t = toText(mon); // also works, since WeekDay <: Day +``` + +`t1 <: t2`: `t1` can be used wherever `t2` is expected + +`Employee <: Person` + +``` motoko +type Employee = {first : Text; last : Text; var salary : Nat}; +type Person = {first : Text; last : Text}; + +func toText(p : Person) : Text { + p.last # "," # p.first; +}; + +let employee : Employee = + { first = "John"; last = "Doe"; var salary = 161_401}; + +let t = toText(employee); // also works, since Employee <: Person +``` + +# Fin + +## Not covered + +- Polymorphic functions with type bounds + +- User defined iterator objects, supporting `for` loops. + +- Actor classes + +- `debug_show` for conversion of almost any value to text. + +- `debug e` expressions for debug-only compilation + +- `do ? { … e! … }` blocks for handling/propagating option values. + +- `assert e` expressions for conditional traps + +- tools: + + - `mo_doc` (generates doc from doc comments), + + - `vessel` (package manager) + + - `mo_ide` (LSP language server for VSCode, emacs etc) + + diff --git a/doc/docusaurus/docusaurus.config.js b/doc/docusaurus/docusaurus.config.js index 7513f3bd8ca..1d65eee6413 100644 --- a/doc/docusaurus/docusaurus.config.js +++ b/doc/docusaurus/docusaurus.config.js @@ -65,7 +65,7 @@ const config = { items: [ { type: 'doc', - docId: 'motoko', + docId: 'writing-motoko/writing-intro', position: 'left', label: 'Doc', }, @@ -90,7 +90,7 @@ const config = { items: [ { label: 'Motoko', - to: '/docs/intro', + to: '/docs/attic/motoko', }, { label: 'Base', diff --git a/doc/docusaurus/package-lock.json b/doc/docusaurus/package-lock.json index f2d9241e1c2..13dfb59a064 100644 --- a/doc/docusaurus/package-lock.json +++ b/doc/docusaurus/package-lock.json @@ -31,99 +31,115 @@ } }, "node_modules/@algolia/autocomplete-core": { - "version": "1.7.1", - "resolved": "https://registry.npmjs.org/@algolia/autocomplete-core/-/autocomplete-core-1.7.1.tgz", - "integrity": "sha512-eiZw+fxMzNQn01S8dA/hcCpoWCOCwcIIEUtHHdzN5TGB3IpzLbuhqFeTfh2OUhhgkE8Uo17+wH+QJ/wYyQmmzg==", + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-core/-/autocomplete-core-1.9.3.tgz", + "integrity": "sha512-009HdfugtGCdC4JdXUbVJClA0q0zh24yyePn+KUGk3rP7j8FEe/m5Yo/z65gn6nP/cM39PxpzqKrL7A6fP6PPw==", + "dependencies": { + "@algolia/autocomplete-plugin-algolia-insights": "1.9.3", + "@algolia/autocomplete-shared": "1.9.3" + } + }, + "node_modules/@algolia/autocomplete-plugin-algolia-insights": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.9.3.tgz", + "integrity": "sha512-a/yTUkcO/Vyy+JffmAnTWbr4/90cLzw+CC3bRbhnULr/EM0fGNvM13oQQ14f2moLMcVDyAx/leczLlAOovhSZg==", "dependencies": { - "@algolia/autocomplete-shared": "1.7.1" + "@algolia/autocomplete-shared": "1.9.3" + }, + "peerDependencies": { + "search-insights": ">= 1 < 3" } }, "node_modules/@algolia/autocomplete-preset-algolia": { - "version": "1.7.1", - "resolved": "https://registry.npmjs.org/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.7.1.tgz", - "integrity": "sha512-pJwmIxeJCymU1M6cGujnaIYcY3QPOVYZOXhFkWVM7IxKzy272BwCvMFMyc5NpG/QmiObBxjo7myd060OeTNJXg==", + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.9.3.tgz", + "integrity": "sha512-d4qlt6YmrLMYy95n5TB52wtNDr6EgAIPH81dvvvW8UmuWRgxEtY0NJiPwl/h95JtG2vmRM804M0DSwMCNZlzRA==", "dependencies": { - "@algolia/autocomplete-shared": "1.7.1" + "@algolia/autocomplete-shared": "1.9.3" }, "peerDependencies": { - "@algolia/client-search": "^4.9.1", - "algoliasearch": "^4.9.1" + "@algolia/client-search": ">= 4.9.1 < 6", + "algoliasearch": ">= 4.9.1 < 6" } }, "node_modules/@algolia/autocomplete-shared": { - "version": "1.7.1", - "resolved": "https://registry.npmjs.org/@algolia/autocomplete-shared/-/autocomplete-shared-1.7.1.tgz", - "integrity": "sha512-eTmGVqY3GeyBTT8IWiB2K5EuURAqhnumfktAEoHxfDY2o7vg2rSnO16ZtIG0fMgt3py28Vwgq42/bVEuaQV7pg==" + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-shared/-/autocomplete-shared-1.9.3.tgz", + "integrity": "sha512-Wnm9E4Ye6Rl6sTTqjoymD+l8DjSTHsHboVRYrKgEt8Q7UHm9nYbqhN/i0fhUYA3OAEH7WA8x3jfpnmJm3rKvaQ==", + "peerDependencies": { + "@algolia/client-search": ">= 4.9.1 < 6", + "algoliasearch": ">= 4.9.1 < 6" + } }, "node_modules/@algolia/cache-browser-local-storage": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/cache-browser-local-storage/-/cache-browser-local-storage-4.14.0.tgz", - "integrity": "sha512-vSX0uPTgTuWdKOv0DbjFBl5AGlWDzYADtv5ChLBBKHTBhAKp4f9b38zDB0v89pCbcoAGZjtb6UTM+pUEVSTuSw==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/cache-browser-local-storage/-/cache-browser-local-storage-4.23.3.tgz", + "integrity": "sha512-vRHXYCpPlTDE7i6UOy2xE03zHF2C8MEFjPN2v7fRbqVpcOvAUQK81x3Kc21xyb5aSIpYCjWCZbYZuz8Glyzyyg==", "dependencies": { - "@algolia/cache-common": "4.14.0" + "@algolia/cache-common": "4.23.3" } }, "node_modules/@algolia/cache-common": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/cache-common/-/cache-common-4.14.0.tgz", - "integrity": "sha512-9bCWX78td6DEtyVIJc2R8MokniFFgbS5r9ADVvBuBeDtVuNhOwDO/MYZ2WlAQJTwos9TtS9v0iJ9Ym0rDHMldA==" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/cache-common/-/cache-common-4.23.3.tgz", + "integrity": "sha512-h9XcNI6lxYStaw32pHpB1TMm0RuxphF+Ik4o7tcQiodEdpKK+wKufY6QXtba7t3k8eseirEMVB83uFFF3Nu54A==" }, "node_modules/@algolia/cache-in-memory": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/cache-in-memory/-/cache-in-memory-4.14.0.tgz", - "integrity": "sha512-kIH9JjebSsZVxnTjaWarunFkWaHnMZ5vG98KwvQj++I4PCMgk7z/GBm9bMNgPUsDPqHxQ0p9HO/j8YgN6VYxgQ==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/cache-in-memory/-/cache-in-memory-4.23.3.tgz", + "integrity": "sha512-yvpbuUXg/+0rbcagxNT7un0eo3czx2Uf0y4eiR4z4SD7SiptwYTpbuS0IHxcLHG3lq22ukx1T6Kjtk/rT+mqNg==", "dependencies": { - "@algolia/cache-common": "4.14.0" + "@algolia/cache-common": "4.23.3" } }, "node_modules/@algolia/client-account": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/client-account/-/client-account-4.14.0.tgz", - "integrity": "sha512-b0rAB3D2rf5qOeBZbUNcixl9EmiVPz6QgEvP2TC3Ed85+8xdVhtbyLD5EzTHQr2BPXvklo5NK1K5Q3UOZ9ojJQ==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-account/-/client-account-4.23.3.tgz", + "integrity": "sha512-hpa6S5d7iQmretHHF40QGq6hz0anWEHGlULcTIT9tbUssWUriN9AUXIFQ8Ei4w9azD0hc1rUok9/DeQQobhQMA==", "dependencies": { - "@algolia/client-common": "4.14.0", - "@algolia/client-search": "4.14.0", - "@algolia/transporter": "4.14.0" + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/client-analytics": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-4.14.0.tgz", - "integrity": "sha512-HcuAbUP2D2SZiV8pvBd6ZoJNJ1Zu5bvUctCknGS7QVQv4xfeDHFcQulwEPftKBhIoJmVZPsQznpeLf+PTGTA+w==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-4.23.3.tgz", + "integrity": "sha512-LBsEARGS9cj8VkTAVEZphjxTjMVCci+zIIiRhpFun9jGDUlS1XmhCW7CTrnaWeIuCQS/2iPyRqSy1nXPjcBLRA==", "dependencies": { - "@algolia/client-common": "4.14.0", - "@algolia/client-search": "4.14.0", - "@algolia/requester-common": "4.14.0", - "@algolia/transporter": "4.14.0" + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/client-common": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.14.0.tgz", - "integrity": "sha512-7pmtPOicY6QEBQEYinChkVVi0SnDGcgJn1P0GkWxIMD23ZQk7o0/eMAQYqkGR3TET6YB/bZDeDrpL5v4DKN3tg==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.23.3.tgz", + "integrity": "sha512-l6EiPxdAlg8CYhroqS5ybfIczsGUIAC47slLPOMDeKSVXYG1n0qGiz4RjAHLw2aD0xzh2EXZ7aRguPfz7UKDKw==", "dependencies": { - "@algolia/requester-common": "4.14.0", - "@algolia/transporter": "4.14.0" + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/client-personalization": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-4.14.0.tgz", - "integrity": "sha512-O/vADaSZYAzL0o8L+2QeTZr1O3VXu8DjBUXnEWWgn96v6zqTH0aoQsQ7gvYEsGNvTGiZZwNJNruzMaBNG0GNUA==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-4.23.3.tgz", + "integrity": "sha512-3E3yF3Ocr1tB/xOZiuC3doHQBQ2zu2MPTYZ0d4lpfWads2WTKG7ZzmGnsHmm63RflvDeLK/UVx7j2b3QuwKQ2g==", "dependencies": { - "@algolia/client-common": "4.14.0", - "@algolia/requester-common": "4.14.0", - "@algolia/transporter": "4.14.0" + "@algolia/client-common": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/client-search": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.14.0.tgz", - "integrity": "sha512-gFxteVMUzEMq6lDEex/gZKNudrFmOFLuWS9SQCU+sXeTCRw32aY5/RBDigOkD6Yp6nLkfnYWvPnDshwY6WgTbw==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.23.3.tgz", + "integrity": "sha512-P4VAKFHqU0wx9O+q29Q8YVuaowaZ5EM77rxfmGnkHUJggh28useXQdopokgwMeYw2XUht49WX5RcTQ40rZIabw==", "dependencies": { - "@algolia/client-common": "4.14.0", - "@algolia/requester-common": "4.14.0", - "@algolia/transporter": "4.14.0" + "@algolia/client-common": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/events": { @@ -132,47 +148,65 @@ "integrity": "sha512-FQzvOCgoFXAbf5Y6mYozw2aj5KCJoA3m4heImceldzPSMbdyS4atVjJzXKMsfX3wnZTFYwkkt8/z8UesLHlSBQ==" }, "node_modules/@algolia/logger-common": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/logger-common/-/logger-common-4.14.0.tgz", - "integrity": "sha512-1Fw+5Nd4d7NWNA9FhOIIXzESJn+j5VTO/f3YK+XhoOlbAwfMbD32InWEjNglrcHnSO8kpqrizFXveKTx1CzoKw==" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/logger-common/-/logger-common-4.23.3.tgz", + "integrity": "sha512-y9kBtmJwiZ9ZZ+1Ek66P0M68mHQzKRxkW5kAAXYN/rdzgDN0d2COsViEFufxJ0pb45K4FRcfC7+33YB4BLrZ+g==" }, "node_modules/@algolia/logger-console": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/logger-console/-/logger-console-4.14.0.tgz", - "integrity": "sha512-nBJwg1TVdzAZCIA5tIFYKA+QqYGD9iRhO8yEdm68VcOeckyNTQuvJtAkWyvzr2qNL6GD+bN8nUQ8Cf5HFy/wZg==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/logger-console/-/logger-console-4.23.3.tgz", + "integrity": "sha512-8xoiseoWDKuCVnWP8jHthgaeobDLolh00KJAdMe9XPrWPuf1by732jSpgy2BlsLTaT9m32pHI8CRfrOqQzHv3A==", + "dependencies": { + "@algolia/logger-common": "4.23.3" + } + }, + "node_modules/@algolia/recommend": { + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-4.23.3.tgz", + "integrity": "sha512-9fK4nXZF0bFkdcLBRDexsnGzVmu4TSYZqxdpgBW2tEyfuSSY54D4qSRkLmNkrrz4YFvdh2GM1gA8vSsnZPR73w==", "dependencies": { - "@algolia/logger-common": "4.14.0" + "@algolia/cache-browser-local-storage": "4.23.3", + "@algolia/cache-common": "4.23.3", + "@algolia/cache-in-memory": "4.23.3", + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/logger-console": "4.23.3", + "@algolia/requester-browser-xhr": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/requester-node-http": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/requester-browser-xhr": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-4.14.0.tgz", - "integrity": "sha512-J4ND/l0/wOyztyOA3F4kFNIj/QDTeiS45m3hqSCVXpIJn/iq1ZP8zYW5q0/2sEMehO8TawVJiHnXYV0kO0Dk0Q==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-4.23.3.tgz", + "integrity": "sha512-jDWGIQ96BhXbmONAQsasIpTYWslyjkiGu0Quydjlowe+ciqySpiDUrJHERIRfELE5+wFc7hc1Q5hqjGoV7yghw==", "dependencies": { - "@algolia/requester-common": "4.14.0" + "@algolia/requester-common": "4.23.3" } }, "node_modules/@algolia/requester-common": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/requester-common/-/requester-common-4.14.0.tgz", - "integrity": "sha512-8DGIW5keIbAFet2TKGr/C9DVJ1r8IWFjgf4URPHn6NHMf6R+ruQp0gOf7xBP1Bw6JIS3/DbvlGqbw8sNO/N+Hw==" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/requester-common/-/requester-common-4.23.3.tgz", + "integrity": "sha512-xloIdr/bedtYEGcXCiF2muajyvRhwop4cMZo+K2qzNht0CMzlRkm8YsDdj5IaBhshqfgmBb3rTg4sL4/PpvLYw==" }, "node_modules/@algolia/requester-node-http": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-4.14.0.tgz", - "integrity": "sha512-DP0k1H9c6+lR4G/jKG4kez3QW1ksUDSSSSy3I8nhPZErIGgd0IqCTXDt1GwykDEkvYj/l4sA3x8pJtDMW3JSzw==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-4.23.3.tgz", + "integrity": "sha512-zgu++8Uj03IWDEJM3fuNl34s746JnZOWn1Uz5taV1dFyJhVM/kTNw9Ik7YJWiUNHJQXcaD8IXD1eCb0nq/aByA==", "dependencies": { - "@algolia/requester-common": "4.14.0" + "@algolia/requester-common": "4.23.3" } }, "node_modules/@algolia/transporter": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/transporter/-/transporter-4.14.0.tgz", - "integrity": "sha512-AP+8Qxeg0XvQ3rFbj4pIUzDMmtjo5pgBMx/57ADbge5Y4Y9ByDdQNjEKk6QFIe70SAwR/cGzglwYg7nl8mK/OA==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/transporter/-/transporter-4.23.3.tgz", + "integrity": "sha512-Wjl5gttqnf/gQKJA+dafnD0Y6Yw97yvfY8R9h0dQltX1GXTgNs1zWgvtWW0tHl1EgMdhAyw189uWiZMnL3QebQ==", "dependencies": { - "@algolia/cache-common": "4.14.0", - "@algolia/logger-common": "4.14.0", - "@algolia/requester-common": "4.14.0" + "@algolia/cache-common": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/requester-common": "4.23.3" } }, "node_modules/@ampproject/remapping": { @@ -188,44 +222,109 @@ } }, "node_modules/@babel/code-frame": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", - "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==", + "version": "7.22.13", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.13.tgz", + "integrity": "sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==", "dependencies": { - "@babel/highlight": "^7.18.6" + "@babel/highlight": "^7.22.13", + "chalk": "^2.4.2" }, "engines": { "node": ">=6.9.0" } }, + "node_modules/@babel/code-frame/node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/code-frame/node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/code-frame/node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/@babel/code-frame/node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==" + }, + "node_modules/@babel/code-frame/node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/@babel/code-frame/node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/code-frame/node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, "node_modules/@babel/compat-data": { - "version": "7.18.8", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.18.8.tgz", - "integrity": "sha512-HSmX4WZPPK3FUxYp7g2T6EyO8j96HlZJlxmKPSh6KAcqwyDrfx7hKjXpAW/0FhFfTJsR0Yt4lAjLI2coMptIHQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.23.3.tgz", + "integrity": "sha512-BmR4bWbDIoFJmJ9z2cZ8Gmm2MXgEDgjdWgpKmKWUt54UGFJdlj31ECtbaDvCG/qVdG3AQ1SfpZEs01lUFbzLOQ==", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/core": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.18.9.tgz", - "integrity": "sha512-1LIb1eL8APMy91/IMW+31ckrfBM4yCoLaVzoDhZUKSM4cu1L1nIidyxkCgzPAgrC5WEz36IPEr/eSeSF9pIn+g==", - "dependencies": { - "@ampproject/remapping": "^2.1.0", - "@babel/code-frame": "^7.18.6", - "@babel/generator": "^7.18.9", - "@babel/helper-compilation-targets": "^7.18.9", - "@babel/helper-module-transforms": "^7.18.9", - "@babel/helpers": "^7.18.9", - "@babel/parser": "^7.18.9", - "@babel/template": "^7.18.6", - "@babel/traverse": "^7.18.9", - "@babel/types": "^7.18.9", - "convert-source-map": "^1.7.0", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.23.3.tgz", + "integrity": "sha512-Jg+msLuNuCJDyBvFv5+OKOUjWMZgd85bKjbICd3zWrKAo+bJ49HJufi7CQE0q0uR8NGyO6xkCACScNqyjHSZew==", + "dependencies": { + "@ampproject/remapping": "^2.2.0", + "@babel/code-frame": "^7.22.13", + "@babel/generator": "^7.23.3", + "@babel/helper-compilation-targets": "^7.22.15", + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helpers": "^7.23.2", + "@babel/parser": "^7.23.3", + "@babel/template": "^7.22.15", + "@babel/traverse": "^7.23.3", + "@babel/types": "^7.23.3", + "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", - "json5": "^2.2.1", - "semver": "^6.3.0" + "json5": "^2.2.3", + "semver": "^6.3.1" }, "engines": { "node": ">=6.9.0" @@ -236,20 +335,21 @@ } }, "node_modules/@babel/core/node_modules/semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "bin": { "semver": "bin/semver.js" } }, "node_modules/@babel/generator": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.18.9.tgz", - "integrity": "sha512-wt5Naw6lJrL1/SGkipMiFxJjtyczUWTP38deiP1PO60HsBjDeKk08CGC3S8iVuvf0FmTdgKwU1KIXzSKL1G0Ug==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.23.3.tgz", + "integrity": "sha512-keeZWAV4LU3tW0qRi19HRpabC/ilM0HRBBzf9/k8FFiG4KVpiv0FIy4hHfLfFQZNhziCTPTmd59zoyv6DNISzg==", "dependencies": { - "@babel/types": "^7.18.9", + "@babel/types": "^7.23.3", "@jridgewell/gen-mapping": "^0.3.2", + "@jridgewell/trace-mapping": "^0.3.17", "jsesc": "^2.5.1" }, "engines": { @@ -270,65 +370,77 @@ } }, "node_modules/@babel/helper-annotate-as-pure": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.18.6.tgz", - "integrity": "sha512-duORpUiYrEpzKIop6iNbjnwKLAKnJ47csTyRACyEmWj0QdUrm5aqNJGHSSEQSUAvNW0ojX0dOmK9dZduvkfeXA==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.22.5.tgz", + "integrity": "sha512-LvBTxu8bQSQkcyKOU+a1btnNFQ1dMAd0R6PyW3arXes06F6QLWLIrd681bxRPIXlrMGR3XYnW9JyML7dP3qgxg==", "dependencies": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.5" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-builder-binary-assignment-operator-visitor": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.18.9.tgz", - "integrity": "sha512-yFQ0YCHoIqarl8BCRwBL8ulYUaZpz3bNsA7oFepAzee+8/+ImtADXNOmO5vJvsPff3qi+hvpkY/NYBTrBQgdNw==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.22.15.tgz", + "integrity": "sha512-QkBXwGgaoC2GtGZRoma6kv7Szfv06khvhFav67ZExau2RaXzy8MpHSMO2PNoP2XtmQphJQRHFfg77Bq731Yizw==", "dependencies": { - "@babel/helper-explode-assignable-expression": "^7.18.6", - "@babel/types": "^7.18.9" + "@babel/types": "^7.22.15" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-compilation-targets": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.18.9.tgz", - "integrity": "sha512-tzLCyVmqUiFlcFoAPLA/gL9TeYrF61VLNtb+hvkuVaB5SUjW7jcfrglBIX1vUIoT7CLP3bBlIMeyEsIl2eFQNg==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.22.15.tgz", + "integrity": "sha512-y6EEzULok0Qvz8yyLkCvVX+02ic+By2UdOhylwUOvOn9dvYc9mKICJuuU1n1XBI02YWsNsnrY1kc6DVbjcXbtw==", "dependencies": { - "@babel/compat-data": "^7.18.8", - "@babel/helper-validator-option": "^7.18.6", - "browserslist": "^4.20.2", - "semver": "^6.3.0" + "@babel/compat-data": "^7.22.9", + "@babel/helper-validator-option": "^7.22.15", + "browserslist": "^4.21.9", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" }, "engines": { "node": ">=6.9.0" - }, - "peerDependencies": { - "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dependencies": { + "yallist": "^3.0.2" } }, "node_modules/@babel/helper-compilation-targets/node_modules/semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "bin": { "semver": "bin/semver.js" } }, + "node_modules/@babel/helper-compilation-targets/node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==" + }, "node_modules/@babel/helper-create-class-features-plugin": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.18.9.tgz", - "integrity": "sha512-WvypNAYaVh23QcjpMR24CwZY2Nz6hqdOcFdPbNpV56hL5H6KiFheO7Xm1aPdlLQ7d5emYZX7VZwPp9x3z+2opw==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.22.15.tgz", + "integrity": "sha512-jKkwA59IXcvSaiK2UN45kKwSC9o+KuoXsBDvHvU/7BecYIp8GQ2UwrVvFgJASUT+hBnwJx6MhvMCuMzwZZ7jlg==", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-function-name": "^7.18.9", - "@babel/helper-member-expression-to-functions": "^7.18.9", - "@babel/helper-optimise-call-expression": "^7.18.6", - "@babel/helper-replace-supers": "^7.18.9", - "@babel/helper-split-export-declaration": "^7.18.6" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-environment-visitor": "^7.22.5", + "@babel/helper-function-name": "^7.22.5", + "@babel/helper-member-expression-to-functions": "^7.22.15", + "@babel/helper-optimise-call-expression": "^7.22.5", + "@babel/helper-replace-supers": "^7.22.9", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.6", + "semver": "^6.3.1" }, "engines": { "node": ">=6.9.0" @@ -337,13 +449,22 @@ "@babel/core": "^7.0.0" } }, + "node_modules/@babel/helper-create-class-features-plugin/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "bin": { + "semver": "bin/semver.js" + } + }, "node_modules/@babel/helper-create-regexp-features-plugin": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.18.6.tgz", - "integrity": "sha512-7LcpH1wnQLGrI+4v+nPp+zUvIkF9x0ddv1Hkdue10tg3gmRnLy97DXh4STiOf1qeIInyD69Qv5kKSZzKD8B/7A==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.22.15.tgz", + "integrity": "sha512-29FkPLFjn4TPEa3RE7GpW+qbE8tlsu3jntNYNfcGsc49LphF1PQIiD+vMZ1z1xVOKt+93khA9tc2JBs3kBjA7w==", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "regexpu-core": "^5.1.0" + "@babel/helper-annotate-as-pure": "^7.22.5", + "regexpu-core": "^5.3.1", + "semver": "^6.3.1" }, "engines": { "node": ">=6.9.0" @@ -352,142 +473,127 @@ "@babel/core": "^7.0.0" } }, + "node_modules/@babel/helper-create-regexp-features-plugin/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "bin": { + "semver": "bin/semver.js" + } + }, "node_modules/@babel/helper-define-polyfill-provider": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.3.1.tgz", - "integrity": "sha512-J9hGMpJQmtWmj46B3kBHmL38UhJGhYX7eqkcq+2gsstyYt341HmPeWspihX43yVRA0mS+8GGk2Gckc7bY/HCmA==", - "dependencies": { - "@babel/helper-compilation-targets": "^7.13.0", - "@babel/helper-module-imports": "^7.12.13", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/traverse": "^7.13.0", + "version": "0.4.3", + "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.4.3.tgz", + "integrity": "sha512-WBrLmuPP47n7PNwsZ57pqam6G/RGo1vw/87b0Blc53tZNGZ4x7YvZ6HgQe2vo1W/FR20OgjeZuGXzudPiXHFug==", + "dependencies": { + "@babel/helper-compilation-targets": "^7.22.6", + "@babel/helper-plugin-utils": "^7.22.5", "debug": "^4.1.1", "lodash.debounce": "^4.0.8", - "resolve": "^1.14.2", - "semver": "^6.1.2" + "resolve": "^1.14.2" }, "peerDependencies": { - "@babel/core": "^7.4.0-0" - } - }, - "node_modules/@babel/helper-define-polyfill-provider/node_modules/semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", - "bin": { - "semver": "bin/semver.js" + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" } }, "node_modules/@babel/helper-environment-visitor": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz", - "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==", - "engines": { - "node": ">=6.9.0" - } - }, - "node_modules/@babel/helper-explode-assignable-expression": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.18.6.tgz", - "integrity": "sha512-eyAYAsQmB80jNfg4baAtLeWAQHfHFiR483rzFK+BhETlGZaQC9bsfrugfXDCbRHLQbIA7U5NxhhOxN7p/dWIcg==", - "dependencies": { - "@babel/types": "^7.18.6" - }, + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.20.tgz", + "integrity": "sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-function-name": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.18.9.tgz", - "integrity": "sha512-fJgWlZt7nxGksJS9a0XdSaI4XvpExnNIgRP+rVefWh5U7BL8pPuir6SJUmFKRfjWQ51OtWSzwOxhaH/EBWWc0A==", + "version": "7.23.0", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.23.0.tgz", + "integrity": "sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==", "dependencies": { - "@babel/template": "^7.18.6", - "@babel/types": "^7.18.9" + "@babel/template": "^7.22.15", + "@babel/types": "^7.23.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-hoist-variables": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz", - "integrity": "sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz", + "integrity": "sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==", "dependencies": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.5" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-member-expression-to-functions": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.18.9.tgz", - "integrity": "sha512-RxifAh2ZoVU67PyKIO4AMi1wTenGfMR/O/ae0CCRqwgBAt5v7xjdtRw7UoSbsreKrQn5t7r89eruK/9JjYHuDg==", + "version": "7.23.0", + "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.23.0.tgz", + "integrity": "sha512-6gfrPwh7OuT6gZyJZvd6WbTfrqAo7vm4xCzAXOusKqq/vWdKXphTpj5klHKNmRUU6/QRGlBsyU9mAIPaWHlqJA==", "dependencies": { - "@babel/types": "^7.18.9" + "@babel/types": "^7.23.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-module-imports": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz", - "integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.22.15.tgz", + "integrity": "sha512-0pYVBnDKZO2fnSPCrgM/6WMc7eS20Fbok+0r88fp+YtWVLZrp4CkafFGIp+W0VKw4a22sgebPT99y+FDNMdP4w==", "dependencies": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.15" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-module-transforms": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.18.9.tgz", - "integrity": "sha512-KYNqY0ICwfv19b31XzvmI/mfcylOzbLtowkw+mfvGPAQ3kfCnMLYbED3YecL5tPd8nAYFQFAd6JHp2LxZk/J1g==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.23.3.tgz", + "integrity": "sha512-7bBs4ED9OmswdfDzpz4MpWgSrV7FXlc3zIagvLFjS5H+Mk7Snr21vQ6QwrsoCGMfNC4e4LQPdoULEt4ykz0SRQ==", "dependencies": { - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-module-imports": "^7.18.6", - "@babel/helper-simple-access": "^7.18.6", - "@babel/helper-split-export-declaration": "^7.18.6", - "@babel/helper-validator-identifier": "^7.18.6", - "@babel/template": "^7.18.6", - "@babel/traverse": "^7.18.9", - "@babel/types": "^7.18.9" + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-simple-access": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.6", + "@babel/helper-validator-identifier": "^7.22.20" }, "engines": { "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" } }, "node_modules/@babel/helper-optimise-call-expression": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.18.6.tgz", - "integrity": "sha512-HP59oD9/fEHQkdcbgFCnbmgH5vIQTJbxh2yf+CdM89/glUNnuzr87Q8GIjGEnOktTROemO0Pe0iPAYbqZuOUiA==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.22.5.tgz", + "integrity": "sha512-HBwaojN0xFRx4yIvpwGqxiV2tUfl7401jlok564NgB9EHS1y6QT17FmKWm4ztqjeVdXLuC4fSvHc5ePpQjoTbw==", "dependencies": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.5" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-plugin-utils": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.18.9.tgz", - "integrity": "sha512-aBXPT3bmtLryXaoJLyYPXPlSD4p1ld9aYeR+sJNOZjJJGiOpb+fKfh3NkcCu7J54nUJwCERPBExCCpyCOHnu/w==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz", + "integrity": "sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-remap-async-to-generator": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.18.9.tgz", - "integrity": "sha512-dI7q50YKd8BAv3VEfgg7PS7yD3Rtbi2J1XMXaalXO0W0164hYLnh8zpjRS0mte9MfVp/tltvr/cfdXPvJr1opA==", + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.22.20.tgz", + "integrity": "sha512-pBGyV4uBqOns+0UvhsTO8qgl8hO89PmiDYv+/COyp1aeMcmfrfruz+/nCMFiYyFF/Knn0yfrC85ZzNFjembFTw==", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-wrap-function": "^7.18.9", - "@babel/types": "^7.18.9" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-wrap-function": "^7.22.20" }, "engines": { "node": ">=6.9.0" @@ -497,103 +603,111 @@ } }, "node_modules/@babel/helper-replace-supers": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.18.9.tgz", - "integrity": "sha512-dNsWibVI4lNT6HiuOIBr1oyxo40HvIVmbwPUm3XZ7wMh4k2WxrxTqZwSqw/eEmXDS9np0ey5M2bz9tBmO9c+YQ==", + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.22.20.tgz", + "integrity": "sha512-qsW0In3dbwQUbK8kejJ4R7IHVGwHJlV6lpG6UA7a9hSa2YEiAib+N1T2kr6PEeUT+Fl7najmSOS6SmAwCHK6Tw==", "dependencies": { - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-member-expression-to-functions": "^7.18.9", - "@babel/helper-optimise-call-expression": "^7.18.6", - "@babel/traverse": "^7.18.9", - "@babel/types": "^7.18.9" + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-member-expression-to-functions": "^7.22.15", + "@babel/helper-optimise-call-expression": "^7.22.5" }, "engines": { "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" } }, "node_modules/@babel/helper-simple-access": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.18.6.tgz", - "integrity": "sha512-iNpIgTgyAvDQpDj76POqg+YEt8fPxx3yaNBg3S30dxNKm2SWfYhD0TGrK/Eu9wHpUW63VQU894TsTg+GLbUa1g==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.22.5.tgz", + "integrity": "sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==", "dependencies": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.5" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-skip-transparent-expression-wrappers": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.18.9.tgz", - "integrity": "sha512-imytd2gHi3cJPsybLRbmFrF7u5BIEuI2cNheyKi3/iOBC63kNn3q8Crn2xVuESli0aM4KYsyEqKyS7lFL8YVtw==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.22.5.tgz", + "integrity": "sha512-tK14r66JZKiC43p8Ki33yLBVJKlQDFoA8GYN67lWCDCqoL6EMMSuM9b+Iff2jHaM/RRFYl7K+iiru7hbRqNx8Q==", "dependencies": { - "@babel/types": "^7.18.9" + "@babel/types": "^7.22.5" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-split-export-declaration": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz", - "integrity": "sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==", + "version": "7.22.6", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz", + "integrity": "sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==", "dependencies": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.5" }, "engines": { "node": ">=6.9.0" } }, + "node_modules/@babel/helper-string-parser": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz", + "integrity": "sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==", + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/@babel/helper-validator-identifier": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.18.6.tgz", - "integrity": "sha512-MmetCkz9ej86nJQV+sFCxoGGrUbU3q02kgLciwkrt9QqEB7cP39oKEY0PakknEO0Gu20SskMRi+AYZ3b1TpN9g==", + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz", + "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-validator-option": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.18.6.tgz", - "integrity": "sha512-XO7gESt5ouv/LRJdrVjkShckw6STTaB7l9BrpBaAHDeF5YZT+01PCwmR0SJHnkW6i8OwW/EVWRShfi4j2x+KQw==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.22.15.tgz", + "integrity": "sha512-bMn7RmyFjY/mdECUbgn9eoSY4vqvacUnS9i9vGAGttgFWesO6B4CYWA7XlpbWgBt71iv/hfbPlynohStqnu5hA==", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-wrap-function": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.18.9.tgz", - "integrity": "sha512-cG2ru3TRAL6a60tfQflpEfs4ldiPwF6YW3zfJiRgmoFVIaC1vGnBBgatfec+ZUziPHkHSaXAuEck3Cdkf3eRpQ==", + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.22.20.tgz", + "integrity": "sha512-pms/UwkOpnQe/PDAEdV/d7dVCoBbB+R4FvYoHGZz+4VPcg7RtYy2KP7S2lbuWM6FCSgob5wshfGESbC/hzNXZw==", "dependencies": { - "@babel/helper-function-name": "^7.18.9", - "@babel/template": "^7.18.6", - "@babel/traverse": "^7.18.9", - "@babel/types": "^7.18.9" + "@babel/helper-function-name": "^7.22.5", + "@babel/template": "^7.22.15", + "@babel/types": "^7.22.19" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helpers": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.18.9.tgz", - "integrity": "sha512-Jf5a+rbrLoR4eNdUmnFu8cN5eNJT6qdTdOg5IHIzq87WwyRw9PwguLFOWYgktN/60IP4fgDUawJvs7PjQIzELQ==", + "version": "7.23.2", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.23.2.tgz", + "integrity": "sha512-lzchcp8SjTSVe/fPmLwtWVBFC7+Tbn8LGHDVfDp9JGxpAY5opSaEFgt8UQvrnECWOTdji2mOWMz1rOhkHscmGQ==", "dependencies": { - "@babel/template": "^7.18.6", - "@babel/traverse": "^7.18.9", - "@babel/types": "^7.18.9" + "@babel/template": "^7.22.15", + "@babel/traverse": "^7.23.2", + "@babel/types": "^7.23.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/highlight": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz", - "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==", + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.22.20.tgz", + "integrity": "sha512-dkdMCN3py0+ksCgYmGG8jKeGA/8Tk+gJwSYYlFGxG5lmhfKNoAy004YpLxpS1W2J8m/EK2Ew+yOs9pVRwO89mg==", "dependencies": { - "@babel/helper-validator-identifier": "^7.18.6", - "chalk": "^2.0.0", + "@babel/helper-validator-identifier": "^7.22.20", + "chalk": "^2.4.2", "js-tokens": "^4.0.0" }, "engines": { @@ -665,9 +779,9 @@ } }, "node_modules/@babel/parser": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.18.9.tgz", - "integrity": "sha512-9uJveS9eY9DJ0t64YbIBZICtJy8a5QrDEVdiLCG97fVLpDTpGX7t8mMSb6OWw6Lrnjqj4O8zwjELX3dhoMgiBg==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.23.3.tgz", + "integrity": "sha512-uVsWNvlVsIninV2prNz/3lHCb+5CJ+e+IUBfbjToAHODtfGYLfCFuY4AU7TskI+dAKk+njsPiBjq1gKTvZOBaw==", "bin": { "parser": "bin/babel-parser.js" }, @@ -676,11 +790,11 @@ } }, "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.18.6.tgz", - "integrity": "sha512-Dgxsyg54Fx1d4Nge8UnvTrED63vrwOdPmyvPzlNN/boaliRP54pm3pGzZD1SJUwrBA+Cs/xdG8kXX6Mn/RfISQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.23.3.tgz", + "integrity": "sha512-iRkKcCqb7iGnq9+3G6rZ+Ciz5VywC4XNRHe57lKM+jOeYAoR0lVqdeeDRfh0tQcTfw/+vBhHn926FmQhLtlFLQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -690,13 +804,13 @@ } }, "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.18.9.tgz", - "integrity": "sha512-AHrP9jadvH7qlOj6PINbgSuphjQUAK7AOT7DPjBo9EHoLhQTnnK5u45e1Hd4DbSQEO9nqPWtQ89r+XEOWFScKg==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.23.3.tgz", + "integrity": "sha512-WwlxbfMNdVEpQjZmK5mhm7oSwD3dS6eU+Iwsi4Knl9wAletWem7kaRsGOG+8UEbRyqxY4SS5zvtfXwX+jMxUwQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-skip-transparent-expression-wrappers": "^7.18.9", - "@babel/plugin-proposal-optional-chaining": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5", + "@babel/plugin-transform-optional-chaining": "^7.23.3" }, "engines": { "node": ">=6.9.0" @@ -705,91 +819,74 @@ "@babel/core": "^7.13.0" } }, - "node_modules/@babel/plugin-proposal-async-generator-functions": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.18.6.tgz", - "integrity": "sha512-WAz4R9bvozx4qwf74M+sfqPMKfSqwM0phxPTR6iJIi8robgzXwkEgmeJG1gEKhm6sDqT/U9aV3lfcqybIpev8w==", + "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.23.3.tgz", + "integrity": "sha512-XaJak1qcityzrX0/IU5nKHb34VaibwP3saKqG6a/tppelgllOH13LUann4ZCIBcVOeE6H18K4Vx9QKkVww3z/w==", "dependencies": { - "@babel/helper-environment-visitor": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-remap-async-to-generator": "^7.18.6", - "@babel/plugin-syntax-async-generators": "^7.8.4" + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { - "@babel/core": "^7.0.0-0" + "@babel/core": "^7.0.0" } }, - "node_modules/@babel/plugin-proposal-class-properties": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.18.6.tgz", - "integrity": "sha512-cumfXOF0+nzZrrN8Rf0t7M+tF6sZc7vhQwYQck9q1/5w2OExlD+b4v4RpMJFaV1Z7WcDRgO6FqvxqxGlwo+RHQ==", + "node_modules/@babel/plugin-proposal-object-rest-spread": { + "version": "7.12.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.12.1.tgz", + "integrity": "sha512-s6SowJIjzlhx8o7lsFx5zmY4At6CTtDvgNQDdPzkBQucle58A6b/TTeEBYtyDgmcXjUTM+vE8YOGHZzzbc/ioA==", + "deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-object-rest-spread instead.", "dependencies": { - "@babel/helper-create-class-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" - }, - "engines": { - "node": ">=6.9.0" + "@babel/helper-plugin-utils": "^7.10.4", + "@babel/plugin-syntax-object-rest-spread": "^7.8.0", + "@babel/plugin-transform-parameters": "^7.12.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-class-static-block": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-static-block/-/plugin-proposal-class-static-block-7.18.6.tgz", - "integrity": "sha512-+I3oIiNxrCpup3Gi8n5IGMwj0gOCAjcJUSQEcotNnCCPMEnixawOQ+KeJPlgfjzx+FKQ1QSyZOWe7wmoJp7vhw==", - "dependencies": { - "@babel/helper-create-class-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-class-static-block": "^7.14.5" - }, + "node_modules/@babel/plugin-proposal-private-property-in-object": { + "version": "7.21.0-placeholder-for-preset-env.2", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz", + "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==", "engines": { "node": ">=6.9.0" }, "peerDependencies": { - "@babel/core": "^7.12.0" + "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-dynamic-import": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.18.6.tgz", - "integrity": "sha512-1auuwmK+Rz13SJj36R+jqFPMJWyKEDd7lLSdOj4oJK0UTgGueSAtkrCvz9ewmgyU/P941Rv2fQwZJN8s6QruXw==", + "node_modules/@babel/plugin-syntax-async-generators": { + "version": "7.8.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", + "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-dynamic-import": "^7.8.3" - }, - "engines": { - "node": ">=6.9.0" + "@babel/helper-plugin-utils": "^7.8.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-export-namespace-from": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.18.9.tgz", - "integrity": "sha512-k1NtHyOMvlDDFeb9G5PhUXuGj8m/wiwojgQVEhJ/fsVsMCpLyOP4h0uGEjYJKrRI+EVPlb5Jk+Gt9P97lOGwtA==", + "node_modules/@babel/plugin-syntax-class-properties": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz", + "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/plugin-syntax-export-namespace-from": "^7.8.3" - }, - "engines": { - "node": ">=6.9.0" + "@babel/helper-plugin-utils": "^7.12.13" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-json-strings": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.18.6.tgz", - "integrity": "sha512-lr1peyn9kOdbYc0xr0OdHTZ5FMqS6Di+H0Fz2I/JwMzGmzJETNeOFq2pBySw6X/KFL5EWDjlJuMsUGRFb8fQgQ==", + "node_modules/@babel/plugin-syntax-class-static-block": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz", + "integrity": "sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-json-strings": "^7.8.3" + "@babel/helper-plugin-utils": "^7.14.5" }, "engines": { "node": ">=6.9.0" @@ -798,43 +895,34 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-logical-assignment-operators": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.18.9.tgz", - "integrity": "sha512-128YbMpjCrP35IOExw2Fq+x55LMP42DzhOhX2aNNIdI9avSWl2PI0yuBWarr3RYpZBSPtabfadkH2yeRiMD61Q==", + "node_modules/@babel/plugin-syntax-dynamic-import": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz", + "integrity": "sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4" - }, - "engines": { - "node": ">=6.9.0" + "@babel/helper-plugin-utils": "^7.8.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-nullish-coalescing-operator": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.18.6.tgz", - "integrity": "sha512-wQxQzxYeJqHcfppzBDnm1yAY0jSRkUXR2z8RePZYrKwMKgMlE8+Z6LUno+bd6LvbGh8Gltvy74+9pIYkr+XkKA==", + "node_modules/@babel/plugin-syntax-export-namespace-from": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-export-namespace-from/-/plugin-syntax-export-namespace-from-7.8.3.tgz", + "integrity": "sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3" - }, - "engines": { - "node": ">=6.9.0" + "@babel/helper-plugin-utils": "^7.8.3" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-numeric-separator": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.18.6.tgz", - "integrity": "sha512-ozlZFogPqoLm8WBr5Z8UckIoE4YQ5KESVcNudyXOR8uqIkliTEgJ3RoketfG6pmzLdeZF0H/wjE9/cCEitBl7Q==", + "node_modules/@babel/plugin-syntax-import-assertions": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.23.3.tgz", + "integrity": "sha512-lPgDSU+SJLK3xmFDTV2ZRQAiM7UuUjGidwBywFavObCiZc1BeAAcMtHJKUya92hPHO+at63JJPLygilZard8jw==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-numeric-separator": "^7.10.4" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -843,16 +931,12 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-object-rest-spread": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.18.9.tgz", - "integrity": "sha512-kDDHQ5rflIeY5xl69CEqGEZ0KY369ehsCIEbTGb4siHG5BE9sga/T0r0OUwyZNLMmZE79E1kbsqAjwFCW4ds6Q==", + "node_modules/@babel/plugin-syntax-import-attributes": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.23.3.tgz", + "integrity": "sha512-pawnE0P9g10xgoP7yKr6CK63K2FMsTE+FZidZO/1PwRdzmAPVs+HS1mAURUsgaoxammTJvULUdIkEK0gOcU2tA==", "dependencies": { - "@babel/compat-data": "^7.18.8", - "@babel/helper-compilation-targets": "^7.18.9", - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/plugin-syntax-object-rest-spread": "^7.8.3", - "@babel/plugin-transform-parameters": "^7.18.8" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -861,44 +945,34 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-optional-catch-binding": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.18.6.tgz", - "integrity": "sha512-Q40HEhs9DJQyaZfUjjn6vE8Cv4GmMHCYuMGIWUnlxH6400VGxOuwWsPt4FxXxJkC/5eOzgn0z21M9gMT4MOhbw==", + "node_modules/@babel/plugin-syntax-import-meta": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", + "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-optional-catch-binding": "^7.8.3" - }, - "engines": { - "node": ">=6.9.0" + "@babel/helper-plugin-utils": "^7.10.4" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-optional-chaining": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.18.9.tgz", - "integrity": "sha512-v5nwt4IqBXihxGsW2QmCWMDS3B3bzGIk/EQVZz2ei7f3NJl8NzAJVvUmpDW5q1CRNY+Beb/k58UAH1Km1N411w==", + "node_modules/@babel/plugin-syntax-json-strings": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", + "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-skip-transparent-expression-wrappers": "^7.18.9", - "@babel/plugin-syntax-optional-chaining": "^7.8.3" - }, - "engines": { - "node": ">=6.9.0" + "@babel/helper-plugin-utils": "^7.8.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-private-methods": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.18.6.tgz", - "integrity": "sha512-nutsvktDItsNn4rpGItSNV2sz1XwS+nfU0Rg8aCx3W3NOKVzdMjJRu0O5OkgDp3ZGICSTbgRpxZoWsxoKRvbeA==", + "node_modules/@babel/plugin-syntax-jsx": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.23.3.tgz", + "integrity": "sha512-EB2MELswq55OHUoRZLGg/zC7QWUKfNLpE57m/S2yr1uEneIgsTgrSzXP3NXEsMkVn76OlaVVnzN+ugObuYGwhg==", "dependencies": { - "@babel/helper-create-class-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -907,78 +981,65 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-private-property-in-object": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.18.6.tgz", - "integrity": "sha512-9Rysx7FOctvT5ouj5JODjAFAkgGoudQuLPamZb0v1TGLpapdNaftzifU8NTWQm0IRjqoYypdrSmyWgkocDQ8Dw==", + "node_modules/@babel/plugin-syntax-logical-assignment-operators": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz", + "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-create-class-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-private-property-in-object": "^7.14.5" - }, - "engines": { - "node": ">=6.9.0" + "@babel/helper-plugin-utils": "^7.10.4" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-proposal-unicode-property-regex": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.18.6.tgz", - "integrity": "sha512-2BShG/d5yoZyXZfVePH91urL5wTG6ASZU9M4o03lKK8u8UW1y08OMttBSOADTcJrnPMpvDXRG3G8fyLh4ovs8w==", + "node_modules/@babel/plugin-syntax-nullish-coalescing-operator": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz", + "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==", "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" - }, - "engines": { - "node": ">=4" + "@babel/helper-plugin-utils": "^7.8.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-async-generators": { - "version": "7.8.4", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", - "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", + "node_modules/@babel/plugin-syntax-numeric-separator": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz", + "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==", "dependencies": { - "@babel/helper-plugin-utils": "^7.8.0" + "@babel/helper-plugin-utils": "^7.10.4" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-class-properties": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz", - "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==", + "node_modules/@babel/plugin-syntax-object-rest-spread": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz", + "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==", "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.8.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-class-static-block": { - "version": "7.14.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz", - "integrity": "sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==", + "node_modules/@babel/plugin-syntax-optional-catch-binding": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz", + "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==", "dependencies": { - "@babel/helper-plugin-utils": "^7.14.5" - }, - "engines": { - "node": ">=6.9.0" + "@babel/helper-plugin-utils": "^7.8.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-dynamic-import": { + "node_modules/@babel/plugin-syntax-optional-chaining": { "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz", - "integrity": "sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", + "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", "dependencies": { "@babel/helper-plugin-utils": "^7.8.0" }, @@ -986,23 +1047,26 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-export-namespace-from": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-export-namespace-from/-/plugin-syntax-export-namespace-from-7.8.3.tgz", - "integrity": "sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==", + "node_modules/@babel/plugin-syntax-private-property-in-object": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz", + "integrity": "sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==", "dependencies": { - "@babel/helper-plugin-utils": "^7.8.3" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-import-assertions": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.18.6.tgz", - "integrity": "sha512-/DU3RXad9+bZwrgWJQKbr39gYbJpLJHezqEzRzi/BHRlJ9zsQb4CK2CA/5apllXNomwA1qHwzvHl+AdEmC5krQ==", + "node_modules/@babel/plugin-syntax-top-level-await": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", + "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.14.5" }, "engines": { "node": ">=6.9.0" @@ -1011,103 +1075,102 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-json-strings": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", - "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", + "node_modules/@babel/plugin-syntax-typescript": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.23.3.tgz", + "integrity": "sha512-9EiNjVJOMwCO+43TqoTrgQ8jMwcAd0sWyXi9RPfIsLTj4R2MADDDQXELhffaUx/uJv2AYcxBgPwH6j4TIA4ytQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.8.0" + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-jsx": { + "node_modules/@babel/plugin-syntax-unicode-sets-regex": { "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.18.6.tgz", - "integrity": "sha512-6mmljtAedFGTWu2p/8WIORGwy+61PLgOMPOdazc7YoJ9ZCWUyFy3A6CpPkRKLKD1ToAesxX8KGEViAiLo9N+7Q==", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz", + "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==", "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.18.6", "@babel/helper-plugin-utils": "^7.18.6" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { - "@babel/core": "^7.0.0-0" + "@babel/core": "^7.0.0" } }, - "node_modules/@babel/plugin-syntax-logical-assignment-operators": { - "version": "7.10.4", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz", - "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==", + "node_modules/@babel/plugin-transform-arrow-functions": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.23.3.tgz", + "integrity": "sha512-NzQcQrzaQPkaEwoTm4Mhyl8jI1huEL/WWIEvudjTCMJ9aBZNpsJbMASx7EQECtQQPS/DcnFpo0FIh3LvEO9cxQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.10.4" + "@babel/helper-plugin-utils": "^7.22.5" }, - "peerDependencies": { - "@babel/core": "^7.0.0-0" - } - }, - "node_modules/@babel/plugin-syntax-nullish-coalescing-operator": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz", - "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==", - "dependencies": { - "@babel/helper-plugin-utils": "^7.8.0" + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-numeric-separator": { - "version": "7.10.4", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz", - "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==", + "node_modules/@babel/plugin-transform-async-generator-functions": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.23.3.tgz", + "integrity": "sha512-59GsVNavGxAXCDDbakWSMJhajASb4kBCqDjqJsv+p5nKdbz7istmZ3HrX3L2LuiI80+zsOADCvooqQH3qGCucQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.10.4" + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-remap-async-to-generator": "^7.22.20", + "@babel/plugin-syntax-async-generators": "^7.8.4" }, - "peerDependencies": { - "@babel/core": "^7.0.0-0" - } - }, - "node_modules/@babel/plugin-syntax-object-rest-spread": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz", - "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==", - "dependencies": { - "@babel/helper-plugin-utils": "^7.8.0" + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-optional-catch-binding": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz", - "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==", + "node_modules/@babel/plugin-transform-async-to-generator": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.23.3.tgz", + "integrity": "sha512-A7LFsKi4U4fomjqXJlZg/u0ft/n8/7n7lpffUP/ZULx/DtV9SGlNKZolHH6PE8Xl1ngCc0M11OaeZptXVkfKSw==", "dependencies": { - "@babel/helper-plugin-utils": "^7.8.0" + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-remap-async-to-generator": "^7.22.20" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-optional-chaining": { - "version": "7.8.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", - "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", + "node_modules/@babel/plugin-transform-block-scoped-functions": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.23.3.tgz", + "integrity": "sha512-vI+0sIaPIO6CNuM9Kk5VmXcMVRiOpDh7w2zZt9GXzmE/9KD70CUEVhvPR/etAeNK/FAEkhxQtXOzVF3EuRL41A==", "dependencies": { - "@babel/helper-plugin-utils": "^7.8.0" + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-private-property-in-object": { - "version": "7.14.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz", - "integrity": "sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==", + "node_modules/@babel/plugin-transform-block-scoping": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.23.3.tgz", + "integrity": "sha512-QPZxHrThbQia7UdvfpaRRlq/J9ciz1J4go0k+lPBXbgaNeY7IQrBj/9ceWjvMMI07/ZBzHl/F0R/2K0qH7jCVw==", "dependencies": { - "@babel/helper-plugin-utils": "^7.14.5" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1116,12 +1179,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-top-level-await": { - "version": "7.14.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", - "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", + "node_modules/@babel/plugin-transform-class-properties": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.23.3.tgz", + "integrity": "sha512-uM+AN8yCIjDPccsKGlw271xjJtGii+xQIF/uMPS8H15L12jZTsLfF4o5vNO7d/oUguOyfdikHGc/yi9ge4SGIg==", "dependencies": { - "@babel/helper-plugin-utils": "^7.14.5" + "@babel/helper-create-class-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1130,26 +1194,36 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-syntax-typescript": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.18.6.tgz", - "integrity": "sha512-mAWAuq4rvOepWCBid55JuRNvpTNf2UGVgoz4JV0fXEKolsVZDzsa4NqCef758WZJj/GDu0gVGItjKFiClTAmZA==", + "node_modules/@babel/plugin-transform-class-static-block": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.23.3.tgz", + "integrity": "sha512-PENDVxdr7ZxKPyi5Ffc0LjXdnJyrJxyqF5T5YjlVg4a0VFfQHW0r8iAtRiDXkfHlu1wwcvdtnndGYIeJLSuRMQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-create-class-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-class-static-block": "^7.14.5" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { - "@babel/core": "^7.0.0-0" + "@babel/core": "^7.12.0" } }, - "node_modules/@babel/plugin-transform-arrow-functions": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.18.6.tgz", - "integrity": "sha512-9S9X9RUefzrsHZmKMbDXxweEH+YlE8JJEuat9FdvW9Qh1cw7W64jELCtWNkPBPX5En45uy28KGvA/AySqUh8CQ==", - "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "node_modules/@babel/plugin-transform-classes": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.23.3.tgz", + "integrity": "sha512-FGEQmugvAEu2QtgtU0uTASXevfLMFfBeVCIIdcQhn/uBQsMTjBajdnAtanQlOcuihWh10PZ7+HWvc7NtBwP74w==", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-compilation-targets": "^7.22.15", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-optimise-call-expression": "^7.22.5", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-replace-supers": "^7.22.20", + "@babel/helper-split-export-declaration": "^7.22.6", + "globals": "^11.1.0" }, "engines": { "node": ">=6.9.0" @@ -1158,14 +1232,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-async-to-generator": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.18.6.tgz", - "integrity": "sha512-ARE5wZLKnTgPW7/1ftQmSi1CmkqqHo2DNmtztFhvgtOWSDfq0Cq9/9L+KnZNYSNrydBekhW3rwShduf59RoXag==", + "node_modules/@babel/plugin-transform-computed-properties": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.23.3.tgz", + "integrity": "sha512-dTj83UVTLw/+nbiHqQSFdwO9CbTtwq1DsDqm3CUEtDrZNET5rT5E6bIdTlOftDTDLMYxvxHNEYO4B9SLl8SLZw==", "dependencies": { - "@babel/helper-module-imports": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-remap-async-to-generator": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/template": "^7.22.15" }, "engines": { "node": ">=6.9.0" @@ -1174,12 +1247,12 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-block-scoped-functions": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.18.6.tgz", - "integrity": "sha512-ExUcOqpPWnliRcPqves5HJcJOvHvIIWfuS4sroBUenPuMdmW+SMHDakmtS7qOo13sVppmUijqeTv7qqGsvURpQ==", + "node_modules/@babel/plugin-transform-destructuring": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.23.3.tgz", + "integrity": "sha512-n225npDqjDIr967cMScVKHXJs7rout1q+tt50inyBCPkyZ8KxeI6d+GIbSBTT/w/9WdlWDOej3V9HE5Lgk57gw==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1188,12 +1261,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-block-scoping": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.18.9.tgz", - "integrity": "sha512-5sDIJRV1KtQVEbt/EIBwGy4T01uYIo4KRB3VUqzkhrAIOGx7AoctL9+Ux88btY0zXdDyPJ9mW+bg+v+XEkGmtw==", + "node_modules/@babel/plugin-transform-dotall-regex": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.23.3.tgz", + "integrity": "sha512-vgnFYDHAKzFaTVp+mneDsIEbnJ2Np/9ng9iviHw3P/KVcgONxpNULEW/51Z/BaFojG2GI2GwwXck5uV1+1NOYQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1202,19 +1276,12 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-classes": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.18.9.tgz", - "integrity": "sha512-EkRQxsxoytpTlKJmSPYrsOMjCILacAjtSVkd4gChEe2kXjFCun3yohhW5I7plXJhCemM0gKsaGMcO8tinvCA5g==", - "dependencies": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-function-name": "^7.18.9", - "@babel/helper-optimise-call-expression": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-replace-supers": "^7.18.9", - "@babel/helper-split-export-declaration": "^7.18.6", - "globals": "^11.1.0" + "node_modules/@babel/plugin-transform-duplicate-keys": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.23.3.tgz", + "integrity": "sha512-RrqQ+BQmU3Oyav3J+7/myfvRCq7Tbz+kKLLshUmMwNlDHExbGL7ARhajvoBJEvc+fCguPPu887N+3RRXBVKZUA==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1223,12 +1290,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-computed-properties": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.18.9.tgz", - "integrity": "sha512-+i0ZU1bCDymKakLxn5srGHrsAPRELC2WIbzwjLhHW9SIE1cPYkLCL0NlnXMZaM1vhfgA2+M7hySk42VBvrkBRw==", + "node_modules/@babel/plugin-transform-dynamic-import": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.23.3.tgz", + "integrity": "sha512-vTG+cTGxPFou12Rj7ll+eD5yWeNl5/8xvQvF08y5Gv3v4mZQoyFf8/n9zg4q5vvCWt5jmgymfzMAldO7orBn7A==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-dynamic-import": "^7.8.3" }, "engines": { "node": ">=6.9.0" @@ -1237,12 +1305,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-destructuring": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.18.9.tgz", - "integrity": "sha512-p5VCYNddPLkZTq4XymQIaIfZNJwT9YsjkPOhkVEqt6QIpQFZVM9IltqqYpOEkJoN1DPznmxUDyZ5CTZs/ZCuHA==", + "node_modules/@babel/plugin-transform-exponentiation-operator": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.23.3.tgz", + "integrity": "sha512-5fhCsl1odX96u7ILKHBj4/Y8vipoqwsJMh4csSA8qFfxrZDEA4Ssku2DyNvMJSmZNOEBT750LfFPbtrnTP90BQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-builder-binary-assignment-operator-visitor": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1251,13 +1320,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-dotall-regex": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.18.6.tgz", - "integrity": "sha512-6S3jpun1eEbAxq7TdjLotAsl4WpQI9DxfkycRcKrjhQYzU87qpXdknpBg/e+TdcMehqGnLFi7tnFUBR02Vq6wg==", + "node_modules/@babel/plugin-transform-export-namespace-from": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.23.3.tgz", + "integrity": "sha512-yCLhW34wpJWRdTxxWtFZASJisihrfyMOTOQexhVzA78jlU+dH7Dw+zQgcPepQ5F3C6bAIiblZZ+qBggJdHiBAg==", "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-export-namespace-from": "^7.8.3" }, "engines": { "node": ">=6.9.0" @@ -1266,12 +1335,12 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-duplicate-keys": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.18.9.tgz", - "integrity": "sha512-d2bmXCtZXYc59/0SanQKbiWINadaJXqtvIQIzd4+hNwkWBgyCd5F/2t1kXoUdvPMrxzPvhK6EMQRROxsue+mfw==", + "node_modules/@babel/plugin-transform-for-of": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.23.3.tgz", + "integrity": "sha512-X8jSm8X1CMwxmK878qsUGJRmbysKNbdpTv/O1/v0LuY/ZkZrng5WYiekYSdg9m09OTmDDUWeEDsTE+17WYbAZw==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1280,13 +1349,14 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-exponentiation-operator": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.18.6.tgz", - "integrity": "sha512-wzEtc0+2c88FVR34aQmiz56dxEkxr2g8DQb/KfaFa1JYXOFVsbhvAonFN6PwVWj++fKmku8NP80plJ5Et4wqHw==", + "node_modules/@babel/plugin-transform-function-name": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.23.3.tgz", + "integrity": "sha512-I1QXp1LxIvt8yLaib49dRW5Okt7Q4oaxao6tFVKS/anCdEOMtYwWVKoiOA1p34GOWIZjUK0E+zCp7+l1pfQyiw==", "dependencies": { - "@babel/helper-builder-binary-assignment-operator-visitor": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-compilation-targets": "^7.22.15", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1295,12 +1365,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-for-of": { - "version": "7.18.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.18.8.tgz", - "integrity": "sha512-yEfTRnjuskWYo0k1mHUqrVWaZwrdq8AYbfrpqULOJOaucGSp4mNMVps+YtA8byoevxS/urwU75vyhQIxcCgiBQ==", + "node_modules/@babel/plugin-transform-json-strings": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.23.3.tgz", + "integrity": "sha512-H9Ej2OiISIZowZHaBwF0tsJOih1PftXJtE8EWqlEIwpc7LMTGq0rPOrywKLQ4nefzx8/HMR0D3JGXoMHYvhi0A==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-json-strings": "^7.8.3" }, "engines": { "node": ">=6.9.0" @@ -1309,14 +1380,12 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-function-name": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.18.9.tgz", - "integrity": "sha512-WvIBoRPaJQ5yVHzcnJFor7oS5Ls0PYixlTYE63lCj2RtdQEl15M68FXQlxnG6wdraJIXRdR7KI+hQ7q/9QjrCQ==", + "node_modules/@babel/plugin-transform-literals": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.23.3.tgz", + "integrity": "sha512-wZ0PIXRxnwZvl9AYpqNUxpZ5BiTGrYt7kueGQ+N5FiQ7RCOD4cm8iShd6S6ggfVIWaJf2EMk8eRzAh52RfP4rQ==", "dependencies": { - "@babel/helper-compilation-targets": "^7.18.9", - "@babel/helper-function-name": "^7.18.9", - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1325,12 +1394,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-literals": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.18.9.tgz", - "integrity": "sha512-IFQDSRoTPnrAIrI5zoZv73IFeZu2dhu6irxQjY9rNjTT53VmKg9fenjvoiOWOkJ6mm4jKVPtdMzBY98Fp4Z4cg==", + "node_modules/@babel/plugin-transform-logical-assignment-operators": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.23.3.tgz", + "integrity": "sha512-+pD5ZbxofyOygEp+zZAfujY2ShNCXRpDRIPOiBmTO693hhyOEteZgl876Xs9SAHPQpcV0vz8LvA/T+w8AzyX8A==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4" }, "engines": { "node": ">=6.9.0" @@ -1340,11 +1410,11 @@ } }, "node_modules/@babel/plugin-transform-member-expression-literals": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.18.6.tgz", - "integrity": "sha512-qSF1ihLGO3q+/g48k85tUjD033C29TNTVB2paCwZPVmOsjn9pClvYYrM2VeJpBY2bcNkuny0YUyTNRyRxJ54KA==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.23.3.tgz", + "integrity": "sha512-sC3LdDBDi5x96LA+Ytekz2ZPk8i/Ck+DEuDbRAll5rknJ5XRTSaPKEYwomLcs1AA8wg9b3KjIQRsnApj+q51Ag==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1354,13 +1424,12 @@ } }, "node_modules/@babel/plugin-transform-modules-amd": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.18.6.tgz", - "integrity": "sha512-Pra5aXsmTsOnjM3IajS8rTaLCy++nGM4v3YR4esk5PCsyg9z8NA5oQLwxzMUtDBd8F+UmVza3VxoAaWCbzH1rg==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.23.3.tgz", + "integrity": "sha512-vJYQGxeKM4t8hYCKVBlZX/gtIY2I7mRGFNcm85sgXGMTBcoV3QdVtdpbcWEbzbfUIUZKwvgFT82mRvaQIebZzw==", "dependencies": { - "@babel/helper-module-transforms": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "babel-plugin-dynamic-import-node": "^2.3.3" + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1370,14 +1439,13 @@ } }, "node_modules/@babel/plugin-transform-modules-commonjs": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.18.6.tgz", - "integrity": "sha512-Qfv2ZOWikpvmedXQJDSbxNqy7Xr/j2Y8/KfijM0iJyKkBTmWuvCA1yeH1yDM7NJhBW/2aXxeucLj6i80/LAJ/Q==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.23.3.tgz", + "integrity": "sha512-aVS0F65LKsdNOtcz6FRCpE4OgsP2OFnW46qNxNIX9h3wuzaNcSQsJysuMwqSibC98HPrf2vCgtxKNwS0DAlgcA==", "dependencies": { - "@babel/helper-module-transforms": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-simple-access": "^7.18.6", - "babel-plugin-dynamic-import-node": "^2.3.3" + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-simple-access": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1387,15 +1455,14 @@ } }, "node_modules/@babel/plugin-transform-modules-systemjs": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.18.9.tgz", - "integrity": "sha512-zY/VSIbbqtoRoJKo2cDTewL364jSlZGvn0LKOf9ntbfxOvjfmyrdtEEOAdswOswhZEb8UH3jDkCKHd1sPgsS0A==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.23.3.tgz", + "integrity": "sha512-ZxyKGTkF9xT9YJuKQRo19ewf3pXpopuYQd8cDXqNzc3mUNbOME0RKMoZxviQk74hwzfQsEe66dE92MaZbdHKNQ==", "dependencies": { - "@babel/helper-hoist-variables": "^7.18.6", - "@babel/helper-module-transforms": "^7.18.9", - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-validator-identifier": "^7.18.6", - "babel-plugin-dynamic-import-node": "^2.3.3" + "@babel/helper-hoist-variables": "^7.22.5", + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-validator-identifier": "^7.22.20" }, "engines": { "node": ">=6.9.0" @@ -1405,12 +1472,12 @@ } }, "node_modules/@babel/plugin-transform-modules-umd": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.18.6.tgz", - "integrity": "sha512-dcegErExVeXcRqNtkRU/z8WlBLnvD4MRnHgNs3MytRO1Mn1sHRyhbcpYbVMGclAqOjdW+9cfkdZno9dFdfKLfQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.23.3.tgz", + "integrity": "sha512-zHsy9iXX2nIsCBFPud3jKn1IRPWg3Ing1qOZgeKV39m1ZgIdpJqvlWVeiHBZC6ITRG0MfskhYe9cLgntfSFPIg==", "dependencies": { - "@babel/helper-module-transforms": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1420,12 +1487,12 @@ } }, "node_modules/@babel/plugin-transform-named-capturing-groups-regex": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.18.6.tgz", - "integrity": "sha512-UmEOGF8XgaIqD74bC8g7iV3RYj8lMf0Bw7NJzvnS9qQhM4mg+1WHKotUIdjxgD2RGrgFLZZPCFPFj3P/kVDYhg==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.22.5.tgz", + "integrity": "sha512-YgLLKmS3aUBhHaxp5hi1WJTgOUb/NCuDHzGT9z9WTt3YG+CPRhJs6nprbStx6DnWM4dh6gt7SU3sZodbZ08adQ==", "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-create-regexp-features-plugin": "^7.22.5", + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1435,11 +1502,11 @@ } }, "node_modules/@babel/plugin-transform-new-target": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.18.6.tgz", - "integrity": "sha512-DjwFA/9Iu3Z+vrAn+8pBUGcjhxKguSMlsFqeCKbhb9BAV756v0krzVK04CRDi/4aqmk8BsHb4a/gFcaA5joXRw==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.23.3.tgz", + "integrity": "sha512-YJ3xKqtJMAT5/TIZnpAR3I+K+WaDowYbN3xyxI8zxx/Gsypwf9B9h0VB+1Nh6ACAAPRS5NSRje0uVv5i79HYGQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1448,13 +1515,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-object-super": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.18.6.tgz", - "integrity": "sha512-uvGz6zk+pZoS1aTZrOvrbj6Pp/kK2mp45t2B+bTDre2UgsZZ8EZLSJtUg7m/no0zOJUWgFONpB7Zv9W2tSaFlA==", + "node_modules/@babel/plugin-transform-nullish-coalescing-operator": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.23.3.tgz", + "integrity": "sha512-xzg24Lnld4DYIdysyf07zJ1P+iIfJpxtVFOzX4g+bsJ3Ng5Le7rXx9KwqKzuyaUeRnt+I1EICwQITqc0E2PmpA==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-replace-supers": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3" }, "engines": { "node": ">=6.9.0" @@ -1463,12 +1530,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-parameters": { - "version": "7.18.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.18.8.tgz", - "integrity": "sha512-ivfbE3X2Ss+Fj8nnXvKJS6sjRG4gzwPMsP+taZC+ZzEGjAYlvENixmt1sZ5Ca6tWls+BlKSGKPJ6OOXvXCbkFg==", + "node_modules/@babel/plugin-transform-numeric-separator": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.23.3.tgz", + "integrity": "sha512-s9GO7fIBi/BLsZ0v3Rftr6Oe4t0ctJ8h4CCXfPoEJwmvAPMyNrfkOOJzm6b9PX9YXcCJWWQd/sBF/N26eBiMVw==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-numeric-separator": "^7.10.4" }, "engines": { "node": ">=6.9.0" @@ -1477,12 +1545,16 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-property-literals": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.18.6.tgz", - "integrity": "sha512-cYcs6qlgafTud3PAzrrRNbQtfpQ8+y/+M5tKmksS9+M1ckbH6kzY8MrexEM9mcA6JDsukE19iIRvAyYl463sMg==", + "node_modules/@babel/plugin-transform-object-rest-spread": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.23.3.tgz", + "integrity": "sha512-VxHt0ANkDmu8TANdE9Kc0rndo/ccsmfe2Cx2y5sI4hu3AukHQ5wAu4cM7j3ba8B9548ijVyclBU+nuDQftZsog==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/compat-data": "^7.23.3", + "@babel/helper-compilation-targets": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-transform-parameters": "^7.23.3" }, "engines": { "node": ">=6.9.0" @@ -1491,12 +1563,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-react-constant-elements": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.18.9.tgz", - "integrity": "sha512-IrTYh1I3YCEL1trjknnlLKTp5JggjzhKl/d3ibzPc97JhpFcDTr38Jdek/oX4cFbS6By0bXJcOkpRvJ5ZHK2wQ==", + "node_modules/@babel/plugin-transform-object-super": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.23.3.tgz", + "integrity": "sha512-BwQ8q0x2JG+3lxCVFohg+KbQM7plfpBwThdW9A6TMtWwLsbDA01Ek2Zb/AgDN39BiZsExm4qrXxjk+P1/fzGrA==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-replace-supers": "^7.22.20" }, "engines": { "node": ">=6.9.0" @@ -1505,12 +1578,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-react-display-name": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.18.6.tgz", - "integrity": "sha512-TV4sQ+T013n61uMoygyMRm+xf04Bd5oqFpv2jAEQwSZ8NwQA7zeRPg1LMVg2PWi3zWBz+CLKD+v5bcpZ/BS0aA==", + "node_modules/@babel/plugin-transform-optional-catch-binding": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.23.3.tgz", + "integrity": "sha512-LxYSb0iLjUamfm7f1D7GpiS4j0UAC8AOiehnsGAP8BEsIX8EOi3qV6bbctw8M7ZvLtcoZfZX5Z7rN9PlWk0m5A==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3" }, "engines": { "node": ">=6.9.0" @@ -1519,16 +1593,14 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-react-jsx": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.18.6.tgz", - "integrity": "sha512-Mz7xMPxoy9kPS/JScj6fJs03TZ/fZ1dJPlMjRAgTaxaS0fUBk8FV/A2rRgfPsVCZqALNwMexD+0Uaf5zlcKPpw==", + "node_modules/@babel/plugin-transform-optional-chaining": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.23.3.tgz", + "integrity": "sha512-zvL8vIfIUgMccIAK1lxjvNv572JHFJIKb4MWBz5OGdBQA0fB0Xluix5rmOby48exiJc987neOmP/m9Fnpkz3Tg==", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-module-imports": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-jsx": "^7.18.6", - "@babel/types": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5", + "@babel/plugin-syntax-optional-chaining": "^7.8.3" }, "engines": { "node": ">=6.9.0" @@ -1537,12 +1609,12 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-react-jsx-development": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.18.6.tgz", - "integrity": "sha512-SA6HEjwYFKF7WDjWcMcMGUimmw/nhNRDWxr+KaLSCrkD/LMDBvWRmHAYgE1HDeF8KUuI8OAu+RT6EOtKxSW2qA==", + "node_modules/@babel/plugin-transform-parameters": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.23.3.tgz", + "integrity": "sha512-09lMt6UsUb3/34BbECKVbVwrT9bO6lILWln237z7sLaWnMsTi7Yc9fhX5DLpkJzAGfaReXI22wP41SZmnAA3Vw==", "dependencies": { - "@babel/plugin-transform-react-jsx": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1551,13 +1623,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-react-pure-annotations": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.18.6.tgz", - "integrity": "sha512-I8VfEPg9r2TRDdvnHgPepTKvuRomzA8+u+nhY7qSI1fR2hRNebasZEETLyM5mAUr0Ku56OkXJ0I7NHJnO6cJiQ==", + "node_modules/@babel/plugin-transform-private-methods": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.23.3.tgz", + "integrity": "sha512-UzqRcRtWsDMTLrRWFvUBDwmw06tCQH9Rl1uAjfh6ijMSmGYQ+fpdB+cnqRC8EMh5tuuxSv0/TejGL+7vyj+50g==", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-create-class-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1566,13 +1638,15 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-regenerator": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.18.6.tgz", - "integrity": "sha512-poqRI2+qiSdeldcz4wTSTXBRryoq3Gc70ye7m7UD5Ww0nE29IXqMl6r7Nd15WBgRd74vloEMlShtH6CKxVzfmQ==", + "node_modules/@babel/plugin-transform-private-property-in-object": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.23.3.tgz", + "integrity": "sha512-a5m2oLNFyje2e/rGKjVfAELTVI5mbA0FeZpBnkOWWV7eSmKQ+T/XW0Vf+29ScLzSxX+rnsarvU0oie/4m6hkxA==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6", - "regenerator-transform": "^0.15.0" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-create-class-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5" }, "engines": { "node": ">=6.9.0" @@ -1581,12 +1655,12 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-reserved-words": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.18.6.tgz", - "integrity": "sha512-oX/4MyMoypzHjFrT1CdivfKZ+XvIPMFXwwxHp/r0Ddy2Vuomt4HDFGmft1TAY2yiTKiNSsh3kjBAzcM8kSdsjA==", + "node_modules/@babel/plugin-transform-property-literals": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.23.3.tgz", + "integrity": "sha512-jR3Jn3y7cZp4oEWPFAlRsSWjxKe4PZILGBSd4nis1TsC5qeSpb+nrtihJuDhNI7QHiVbUaiXa0X2RZY3/TI6Nw==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1595,17 +1669,12 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-runtime": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.18.9.tgz", - "integrity": "sha512-wS8uJwBt7/b/mzE13ktsJdmS4JP/j7PQSaADtnb4I2wL0zK51MQ0pmF8/Jy0wUIS96fr+fXT6S/ifiPXnvrlSg==", - "dependencies": { - "@babel/helper-module-imports": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.9", - "babel-plugin-polyfill-corejs2": "^0.3.1", - "babel-plugin-polyfill-corejs3": "^0.5.2", - "babel-plugin-polyfill-regenerator": "^0.3.1", - "semver": "^6.3.0" + "node_modules/@babel/plugin-transform-react-constant-elements": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.23.3.tgz", + "integrity": "sha512-zP0QKq/p6O42OL94udMgSfKXyse4RyJ0JqbQ34zDAONWjyrEsghYEyTSK5FIpmXmCpB55SHokL1cRRKHv8L2Qw==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1614,20 +1683,12 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-runtime/node_modules/semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", - "bin": { - "semver": "bin/semver.js" - } - }, - "node_modules/@babel/plugin-transform-shorthand-properties": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.18.6.tgz", - "integrity": "sha512-eCLXXJqv8okzg86ywZJbRn19YJHU4XUa55oz2wbHhaQVn/MM+XhukiT7SYqp/7o00dg52Rj51Ny+Ecw4oyoygw==", + "node_modules/@babel/plugin-transform-react-display-name": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.23.3.tgz", + "integrity": "sha512-GnvhtVfA2OAtzdX58FJxU19rhoGeQzyVndw3GgtdECQvQFXPEZIOVULHVZGAYmOgmqjXpVpfocAbSjh99V/Fqw==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1636,13 +1697,16 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-spread": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.18.9.tgz", - "integrity": "sha512-39Q814wyoOPtIB/qGopNIL9xDChOE1pNU0ZY5dO0owhiVt/5kFm4li+/bBtwc7QotG0u5EPzqhZdjMtmqBqyQA==", + "node_modules/@babel/plugin-transform-react-jsx": { + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.22.15.tgz", + "integrity": "sha512-oKckg2eZFa8771O/5vi7XeTvmM6+O9cxZu+kanTU7tD4sin5nO/G8jGJhq8Hvt2Z0kUoEDRayuZLaUlYl8QuGA==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-skip-transparent-expression-wrappers": "^7.18.9" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-jsx": "^7.22.5", + "@babel/types": "^7.22.15" }, "engines": { "node": ">=6.9.0" @@ -1651,12 +1715,12 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-sticky-regex": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.18.6.tgz", - "integrity": "sha512-kfiDrDQ+PBsQDO85yj1icueWMfGfJFKN1KCkndygtu/C9+XUfydLC8Iv5UYJqRwy4zk8EcplRxEOeLyjq1gm6Q==", + "node_modules/@babel/plugin-transform-react-jsx-development": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.22.5.tgz", + "integrity": "sha512-bDhuzwWMuInwCYeDeMzyi7TaBgRQei6DqxhbyniL7/VG4RSS7HtSL2QbY4eESy1KJqlWt8g3xeEBGPuo+XqC8A==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/plugin-transform-react-jsx": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1665,12 +1729,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-template-literals": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.18.9.tgz", - "integrity": "sha512-S8cOWfT82gTezpYOiVaGHrCbhlHgKhQt8XH5ES46P2XWmX92yisoZywf5km75wv5sYcXDUCLMmMxOLCtthDgMA==", + "node_modules/@babel/plugin-transform-react-pure-annotations": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.23.3.tgz", + "integrity": "sha512-qMFdSS+TUhB7Q/3HVPnEdYJDQIk57jkntAwSuz9xfSE4n+3I+vHYCli3HoHawN1Z3RfCz/y1zXA/JXjG6cVImQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1679,12 +1744,13 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-typeof-symbol": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.18.9.tgz", - "integrity": "sha512-SRfwTtF11G2aemAZWivL7PD+C9z52v9EvMqH9BuYbabyPuKUvSWks3oCg6041pT925L4zVFqaVBeECwsmlguEw==", + "node_modules/@babel/plugin-transform-regenerator": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.23.3.tgz", + "integrity": "sha512-KP+75h0KghBMcVpuKisx3XTu9Ncut8Q8TuvGO4IhY+9D5DFEckQefOuIsB/gQ2tG71lCke4NMrtIPS8pOj18BQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5", + "regenerator-transform": "^0.15.2" }, "engines": { "node": ">=6.9.0" @@ -1693,14 +1759,12 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-typescript": { - "version": "7.18.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.18.8.tgz", - "integrity": "sha512-p2xM8HI83UObjsZGofMV/EdYjamsDm6MoN3hXPYIT0+gxIoopE+B7rPYKAxfrz9K9PK7JafTTjqYC6qipLExYA==", + "node_modules/@babel/plugin-transform-reserved-words": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.23.3.tgz", + "integrity": "sha512-QnNTazY54YqgGxwIexMZva9gqbPa15t/x9VS+0fsEFWplwVpXYZivtgl43Z1vMpc1bdPP2PP8siFeVcnFvA3Cg==", "dependencies": { - "@babel/helper-create-class-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-typescript": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1709,12 +1773,17 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-unicode-escapes": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.18.6.tgz", - "integrity": "sha512-XNRwQUXYMP7VLuy54cr/KS/WeL3AZeORhrmeZ7iewgu+X2eBqmpaLI/hzqr9ZxCeUoq0ASK4GUzSM0BDhZkLFw==", + "node_modules/@babel/plugin-transform-runtime": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.23.3.tgz", + "integrity": "sha512-XcQ3X58CKBdBnnZpPaQjgVMePsXtSZzHoku70q9tUAQp02ggPQNM04BF3RvlW1GSM/McbSOQAzEK4MXbS7/JFg==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "babel-plugin-polyfill-corejs2": "^0.4.6", + "babel-plugin-polyfill-corejs3": "^0.8.5", + "babel-plugin-polyfill-regenerator": "^0.5.3", + "semver": "^6.3.1" }, "engines": { "node": ">=6.9.0" @@ -1723,13 +1792,20 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/plugin-transform-unicode-regex": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.18.6.tgz", - "integrity": "sha512-gE7A6Lt7YLnNOL3Pb9BNeZvi+d8l7tcRrG4+pwJjK9hD2xX4mEvjlQW60G9EEmfXVYRPv9VRQcyegIVHCql/AA==", + "node_modules/@babel/plugin-transform-runtime/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/plugin-transform-shorthand-properties": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.23.3.tgz", + "integrity": "sha512-ED2fgqZLmexWiN+YNFX26fx4gh5qHDhn1O2gvEhreLW2iI63Sqm4llRLCXALKrCnbN4Jy0VcMQZl/SAzqug/jg==", "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" }, "engines": { "node": ">=6.9.0" @@ -1738,38 +1814,160 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/@babel/plugin-transform-spread": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.23.3.tgz", + "integrity": "sha512-VvfVYlrlBVu+77xVTOAoxQ6mZbnIq5FM0aGBSFEcIh03qHf+zNqA4DC/3XMUozTg7bZV3e3mZQ0i13VB6v5yUg==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-sticky-regex": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.23.3.tgz", + "integrity": "sha512-HZOyN9g+rtvnOU3Yh7kSxXrKbzgrm5X4GncPY1QOquu7epga5MxKHVpYu2hvQnry/H+JjckSYRb93iNfsioAGg==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-template-literals": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.23.3.tgz", + "integrity": "sha512-Flok06AYNp7GV2oJPZZcP9vZdszev6vPBkHLwxwSpaIqx75wn6mUd3UFWsSsA0l8nXAKkyCmL/sR02m8RYGeHg==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-typeof-symbol": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.23.3.tgz", + "integrity": "sha512-4t15ViVnaFdrPC74be1gXBSMzXk3B4Us9lP7uLRQHTFpV5Dvt33pn+2MyyNxmN3VTTm3oTrZVMUmuw3oBnQ2oQ==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-typescript": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.23.3.tgz", + "integrity": "sha512-ogV0yWnq38CFwH20l2Afz0dfKuZBx9o/Y2Rmh5vuSS0YD1hswgEgTfyTzuSrT2q9btmHRSqYoSfwFUVaC1M1Jw==", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-create-class-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-typescript": "^7.23.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-escapes": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.23.3.tgz", + "integrity": "sha512-OMCUx/bU6ChE3r4+ZdylEqAjaQgHAgipgW8nsCfu5pGqDcFytVd91AwRvUJSBZDz0exPGgnjoqhgRYLRjFZc9Q==", + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-property-regex": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.23.3.tgz", + "integrity": "sha512-KcLIm+pDZkWZQAFJ9pdfmh89EwVfmNovFBcXko8szpBeF8z68kWIPeKlmSOkT9BXJxs2C0uk+5LxoxIv62MROA==", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-regex": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.23.3.tgz", + "integrity": "sha512-wMHpNA4x2cIA32b/ci3AfwNgheiva2W0WUKWTK7vBHBhDKfPsc5cFGNWm69WBqpwd86u1qwZ9PWevKqm1A3yAw==", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-sets-regex": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.23.3.tgz", + "integrity": "sha512-W7lliA/v9bNR83Qc3q1ip9CQMZ09CcHDbHfbLRDNuAhn1Mvkr1ZNF7hPmztMQvtTGVLJ9m8IZqWsTkXOml8dbw==", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, "node_modules/@babel/preset-env": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.18.9.tgz", - "integrity": "sha512-75pt/q95cMIHWssYtyfjVlvI+QEZQThQbKvR9xH+F/Agtw/s4Wfc2V9Bwd/P39VtixB7oWxGdH4GteTTwYJWMg==", - "dependencies": { - "@babel/compat-data": "^7.18.8", - "@babel/helper-compilation-targets": "^7.18.9", - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-validator-option": "^7.18.6", - "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.18.6", - "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.18.9", - "@babel/plugin-proposal-async-generator-functions": "^7.18.6", - "@babel/plugin-proposal-class-properties": "^7.18.6", - "@babel/plugin-proposal-class-static-block": "^7.18.6", - "@babel/plugin-proposal-dynamic-import": "^7.18.6", - "@babel/plugin-proposal-export-namespace-from": "^7.18.9", - "@babel/plugin-proposal-json-strings": "^7.18.6", - "@babel/plugin-proposal-logical-assignment-operators": "^7.18.9", - "@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.6", - "@babel/plugin-proposal-numeric-separator": "^7.18.6", - "@babel/plugin-proposal-object-rest-spread": "^7.18.9", - "@babel/plugin-proposal-optional-catch-binding": "^7.18.6", - "@babel/plugin-proposal-optional-chaining": "^7.18.9", - "@babel/plugin-proposal-private-methods": "^7.18.6", - "@babel/plugin-proposal-private-property-in-object": "^7.18.6", - "@babel/plugin-proposal-unicode-property-regex": "^7.18.6", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.23.3.tgz", + "integrity": "sha512-ovzGc2uuyNfNAs/jyjIGxS8arOHS5FENZaNn4rtE7UdKMMkqHCvboHfcuhWLZNX5cB44QfcGNWjaevxMzzMf+Q==", + "dependencies": { + "@babel/compat-data": "^7.23.3", + "@babel/helper-compilation-targets": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-validator-option": "^7.22.15", + "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.23.3", + "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.23.3", + "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.23.3", + "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2", "@babel/plugin-syntax-async-generators": "^7.8.4", "@babel/plugin-syntax-class-properties": "^7.12.13", "@babel/plugin-syntax-class-static-block": "^7.14.5", "@babel/plugin-syntax-dynamic-import": "^7.8.3", "@babel/plugin-syntax-export-namespace-from": "^7.8.3", - "@babel/plugin-syntax-import-assertions": "^7.18.6", + "@babel/plugin-syntax-import-assertions": "^7.23.3", + "@babel/plugin-syntax-import-attributes": "^7.23.3", + "@babel/plugin-syntax-import-meta": "^7.10.4", "@babel/plugin-syntax-json-strings": "^7.8.3", "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4", "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", @@ -1779,45 +1977,61 @@ "@babel/plugin-syntax-optional-chaining": "^7.8.3", "@babel/plugin-syntax-private-property-in-object": "^7.14.5", "@babel/plugin-syntax-top-level-await": "^7.14.5", - "@babel/plugin-transform-arrow-functions": "^7.18.6", - "@babel/plugin-transform-async-to-generator": "^7.18.6", - "@babel/plugin-transform-block-scoped-functions": "^7.18.6", - "@babel/plugin-transform-block-scoping": "^7.18.9", - "@babel/plugin-transform-classes": "^7.18.9", - "@babel/plugin-transform-computed-properties": "^7.18.9", - "@babel/plugin-transform-destructuring": "^7.18.9", - "@babel/plugin-transform-dotall-regex": "^7.18.6", - "@babel/plugin-transform-duplicate-keys": "^7.18.9", - "@babel/plugin-transform-exponentiation-operator": "^7.18.6", - "@babel/plugin-transform-for-of": "^7.18.8", - "@babel/plugin-transform-function-name": "^7.18.9", - "@babel/plugin-transform-literals": "^7.18.9", - "@babel/plugin-transform-member-expression-literals": "^7.18.6", - "@babel/plugin-transform-modules-amd": "^7.18.6", - "@babel/plugin-transform-modules-commonjs": "^7.18.6", - "@babel/plugin-transform-modules-systemjs": "^7.18.9", - "@babel/plugin-transform-modules-umd": "^7.18.6", - "@babel/plugin-transform-named-capturing-groups-regex": "^7.18.6", - "@babel/plugin-transform-new-target": "^7.18.6", - "@babel/plugin-transform-object-super": "^7.18.6", - "@babel/plugin-transform-parameters": "^7.18.8", - "@babel/plugin-transform-property-literals": "^7.18.6", - "@babel/plugin-transform-regenerator": "^7.18.6", - "@babel/plugin-transform-reserved-words": "^7.18.6", - "@babel/plugin-transform-shorthand-properties": "^7.18.6", - "@babel/plugin-transform-spread": "^7.18.9", - "@babel/plugin-transform-sticky-regex": "^7.18.6", - "@babel/plugin-transform-template-literals": "^7.18.9", - "@babel/plugin-transform-typeof-symbol": "^7.18.9", - "@babel/plugin-transform-unicode-escapes": "^7.18.6", - "@babel/plugin-transform-unicode-regex": "^7.18.6", - "@babel/preset-modules": "^0.1.5", - "@babel/types": "^7.18.9", - "babel-plugin-polyfill-corejs2": "^0.3.1", - "babel-plugin-polyfill-corejs3": "^0.5.2", - "babel-plugin-polyfill-regenerator": "^0.3.1", - "core-js-compat": "^3.22.1", - "semver": "^6.3.0" + "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6", + "@babel/plugin-transform-arrow-functions": "^7.23.3", + "@babel/plugin-transform-async-generator-functions": "^7.23.3", + "@babel/plugin-transform-async-to-generator": "^7.23.3", + "@babel/plugin-transform-block-scoped-functions": "^7.23.3", + "@babel/plugin-transform-block-scoping": "^7.23.3", + "@babel/plugin-transform-class-properties": "^7.23.3", + "@babel/plugin-transform-class-static-block": "^7.23.3", + "@babel/plugin-transform-classes": "^7.23.3", + "@babel/plugin-transform-computed-properties": "^7.23.3", + "@babel/plugin-transform-destructuring": "^7.23.3", + "@babel/plugin-transform-dotall-regex": "^7.23.3", + "@babel/plugin-transform-duplicate-keys": "^7.23.3", + "@babel/plugin-transform-dynamic-import": "^7.23.3", + "@babel/plugin-transform-exponentiation-operator": "^7.23.3", + "@babel/plugin-transform-export-namespace-from": "^7.23.3", + "@babel/plugin-transform-for-of": "^7.23.3", + "@babel/plugin-transform-function-name": "^7.23.3", + "@babel/plugin-transform-json-strings": "^7.23.3", + "@babel/plugin-transform-literals": "^7.23.3", + "@babel/plugin-transform-logical-assignment-operators": "^7.23.3", + "@babel/plugin-transform-member-expression-literals": "^7.23.3", + "@babel/plugin-transform-modules-amd": "^7.23.3", + "@babel/plugin-transform-modules-commonjs": "^7.23.3", + "@babel/plugin-transform-modules-systemjs": "^7.23.3", + "@babel/plugin-transform-modules-umd": "^7.23.3", + "@babel/plugin-transform-named-capturing-groups-regex": "^7.22.5", + "@babel/plugin-transform-new-target": "^7.23.3", + "@babel/plugin-transform-nullish-coalescing-operator": "^7.23.3", + "@babel/plugin-transform-numeric-separator": "^7.23.3", + "@babel/plugin-transform-object-rest-spread": "^7.23.3", + "@babel/plugin-transform-object-super": "^7.23.3", + "@babel/plugin-transform-optional-catch-binding": "^7.23.3", + "@babel/plugin-transform-optional-chaining": "^7.23.3", + "@babel/plugin-transform-parameters": "^7.23.3", + "@babel/plugin-transform-private-methods": "^7.23.3", + "@babel/plugin-transform-private-property-in-object": "^7.23.3", + "@babel/plugin-transform-property-literals": "^7.23.3", + "@babel/plugin-transform-regenerator": "^7.23.3", + "@babel/plugin-transform-reserved-words": "^7.23.3", + "@babel/plugin-transform-shorthand-properties": "^7.23.3", + "@babel/plugin-transform-spread": "^7.23.3", + "@babel/plugin-transform-sticky-regex": "^7.23.3", + "@babel/plugin-transform-template-literals": "^7.23.3", + "@babel/plugin-transform-typeof-symbol": "^7.23.3", + "@babel/plugin-transform-unicode-escapes": "^7.23.3", + "@babel/plugin-transform-unicode-property-regex": "^7.23.3", + "@babel/plugin-transform-unicode-regex": "^7.23.3", + "@babel/plugin-transform-unicode-sets-regex": "^7.23.3", + "@babel/preset-modules": "0.1.6-no-external-plugins", + "babel-plugin-polyfill-corejs2": "^0.4.6", + "babel-plugin-polyfill-corejs3": "^0.8.5", + "babel-plugin-polyfill-regenerator": "^0.5.3", + "core-js-compat": "^3.31.0", + "semver": "^6.3.1" }, "engines": { "node": ">=6.9.0" @@ -1827,39 +2041,37 @@ } }, "node_modules/@babel/preset-env/node_modules/semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "bin": { "semver": "bin/semver.js" } }, "node_modules/@babel/preset-modules": { - "version": "0.1.5", - "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.5.tgz", - "integrity": "sha512-A57th6YRG7oR3cq/yt/Y84MvGgE0eJG2F1JLhKuyG+jFxEgrd/HAMJatiFtmOiZurz+0DkrvbheCLaV5f2JfjA==", + "version": "0.1.6-no-external-plugins", + "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz", + "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==", "dependencies": { "@babel/helper-plugin-utils": "^7.0.0", - "@babel/plugin-proposal-unicode-property-regex": "^7.4.4", - "@babel/plugin-transform-dotall-regex": "^7.4.4", "@babel/types": "^7.4.4", "esutils": "^2.0.2" }, "peerDependencies": { - "@babel/core": "^7.0.0-0" + "@babel/core": "^7.0.0-0 || ^8.0.0-0 <8.0.0" } }, "node_modules/@babel/preset-react": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/preset-react/-/preset-react-7.18.6.tgz", - "integrity": "sha512-zXr6atUmyYdiWRVLOZahakYmOBHtWc2WGCkP8PYTgZi0iJXDY2CN180TdrIW4OGOAdLc7TifzDIvtx6izaRIzg==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/preset-react/-/preset-react-7.23.3.tgz", + "integrity": "sha512-tbkHOS9axH6Ysf2OUEqoSZ6T3Fa2SrNH6WTWSPBboxKzdxNc9qOICeLXkNG0ZEwbQ1HY8liwOce4aN/Ceyuq6w==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-validator-option": "^7.18.6", - "@babel/plugin-transform-react-display-name": "^7.18.6", - "@babel/plugin-transform-react-jsx": "^7.18.6", - "@babel/plugin-transform-react-jsx-development": "^7.18.6", - "@babel/plugin-transform-react-pure-annotations": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-validator-option": "^7.22.15", + "@babel/plugin-transform-react-display-name": "^7.23.3", + "@babel/plugin-transform-react-jsx": "^7.22.15", + "@babel/plugin-transform-react-jsx-development": "^7.22.5", + "@babel/plugin-transform-react-pure-annotations": "^7.23.3" }, "engines": { "node": ">=6.9.0" @@ -1869,13 +2081,15 @@ } }, "node_modules/@babel/preset-typescript": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.18.6.tgz", - "integrity": "sha512-s9ik86kXBAnD760aybBucdpnLsAt0jK1xqJn2juOn9lkOvSHV60os5hxoVJsPzMQxvnUJFAlkont2DvvaYEBtQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.23.3.tgz", + "integrity": "sha512-17oIGVlqz6CchO9RFYn5U6ZpWRZIngayYCtrPRSgANSwC2V1Jb+iP74nVxzzXJte8b8BYxrL1yY96xfhTBrNNQ==", "dependencies": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-validator-option": "^7.18.6", - "@babel/plugin-transform-typescript": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-validator-option": "^7.22.15", + "@babel/plugin-syntax-jsx": "^7.23.3", + "@babel/plugin-transform-modules-commonjs": "^7.23.3", + "@babel/plugin-transform-typescript": "^7.23.3" }, "engines": { "node": ">=6.9.0" @@ -1884,55 +2098,60 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/@babel/regjsgen": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/@babel/regjsgen/-/regjsgen-0.8.0.tgz", + "integrity": "sha512-x/rqGMdzj+fWZvCOYForTghzbtqPDZ5gPwaoNGHdgDfF2QA/XZbCBp4Moo5scrkAMPhB7z26XM/AaHuIJdgauA==" + }, "node_modules/@babel/runtime": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.18.9.tgz", - "integrity": "sha512-lkqXDcvlFT5rvEjiu6+QYO+1GXrEHRo2LOtS7E4GtX5ESIZOgepqsZBVIj6Pv+a6zqsya9VCgiK1KAK4BvJDAw==", + "version": "7.23.2", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.23.2.tgz", + "integrity": "sha512-mM8eg4yl5D6i3lu2QKPuPH4FArvJ8KhTofbE7jwMUv9KX5mBvwPAqnV3MlyBNqdp9RyRKP6Yck8TrfYrPvX3bg==", "dependencies": { - "regenerator-runtime": "^0.13.4" + "regenerator-runtime": "^0.14.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/runtime-corejs3": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.18.9.tgz", - "integrity": "sha512-qZEWeccZCrHA2Au4/X05QW5CMdm4VjUDCrGq5gf1ZDcM4hRqreKrtwAn7yci9zfgAS9apvnsFXiGBHBAxZdK9A==", + "version": "7.23.2", + "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.23.2.tgz", + "integrity": "sha512-54cIh74Z1rp4oIjsHjqN+WM4fMyCBYe+LpZ9jWm51CZ1fbH3SkAzQD/3XLoNkjbJ7YEmjobLXyvQrFypRHOrXw==", "dependencies": { - "core-js-pure": "^3.20.2", - "regenerator-runtime": "^0.13.4" + "core-js-pure": "^3.30.2", + "regenerator-runtime": "^0.14.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/template": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.18.6.tgz", - "integrity": "sha512-JoDWzPe+wgBsTTgdnIma3iHNFC7YVJoPssVBDjiHfNlyt4YcunDtcDOUmfVDfCK5MfdsaIoX9PkijPhjH3nYUw==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.22.15.tgz", + "integrity": "sha512-QPErUVm4uyJa60rkI73qneDacvdvzxshT3kksGqlGWYdOTIUOwJ7RDUL8sGqslY1uXWSL6xMFKEXDS3ox2uF0w==", "dependencies": { - "@babel/code-frame": "^7.18.6", - "@babel/parser": "^7.18.6", - "@babel/types": "^7.18.6" + "@babel/code-frame": "^7.22.13", + "@babel/parser": "^7.22.15", + "@babel/types": "^7.22.15" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/traverse": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.18.9.tgz", - "integrity": "sha512-LcPAnujXGwBgv3/WHv01pHtb2tihcyW1XuL9wd7jqh1Z8AQkTd+QVjMrMijrln0T7ED3UXLIy36P9Ao7W75rYg==", - "dependencies": { - "@babel/code-frame": "^7.18.6", - "@babel/generator": "^7.18.9", - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-function-name": "^7.18.9", - "@babel/helper-hoist-variables": "^7.18.6", - "@babel/helper-split-export-declaration": "^7.18.6", - "@babel/parser": "^7.18.9", - "@babel/types": "^7.18.9", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.23.3.tgz", + "integrity": "sha512-+K0yF1/9yR0oHdE0StHuEj3uTPzwwbrLGfNOndVJVV2TqA5+j3oljJUb4nmB954FLGjNem976+B+eDuLIjesiQ==", + "dependencies": { + "@babel/code-frame": "^7.22.13", + "@babel/generator": "^7.23.3", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-hoist-variables": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.6", + "@babel/parser": "^7.23.3", + "@babel/types": "^7.23.3", "debug": "^4.1.0", "globals": "^11.1.0" }, @@ -1941,11 +2160,12 @@ } }, "node_modules/@babel/types": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.18.9.tgz", - "integrity": "sha512-WwMLAg2MvJmt/rKEVQBBhIVffMmnilX4oe0sRe7iPOHIGsqpruFHHdrfj4O1CMMtgMtCU4oPafZjDPCRgO57Wg==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.23.3.tgz", + "integrity": "sha512-OZnvoH2l8PK5eUvEcUyCt/sXgr/h+UWpVuBbOljwcrAgUl6lpchoQ++PHGyQy1AtYnVA6CEq3y5xeEI10brpXw==", "dependencies": { - "@babel/helper-validator-identifier": "^7.18.6", + "@babel/helper-string-parser": "^7.22.5", + "@babel/helper-validator-identifier": "^7.22.20", "to-fast-properties": "^2.0.0" }, "engines": { @@ -1961,25 +2181,48 @@ "node": ">=0.1.90" } }, + "node_modules/@discoveryjs/json-ext": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz", + "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==", + "engines": { + "node": ">=10.0.0" + } + }, "node_modules/@docsearch/css": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-3.1.1.tgz", - "integrity": "sha512-utLgg7E1agqQeqCJn05DWC7XXMk4tMUUnL7MZupcknRu2OzGN13qwey2qA/0NAKkVBGugiWtON0+rlU0QIPojg==" + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-3.6.0.tgz", + "integrity": "sha512-+sbxb71sWre+PwDK7X2T8+bhS6clcVMLwBPznX45Qu6opJcgRjAp7gYSDzVFp187J+feSj5dNBN1mJoi6ckkUQ==" }, "node_modules/@docsearch/react": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-3.1.1.tgz", - "integrity": "sha512-cfoql4qvtsVRqBMYxhlGNpvyy/KlCoPqjIsJSZYqYf9AplZncKjLBTcwBu6RXFMVCe30cIFljniI4OjqAU67pQ==", + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-3.6.0.tgz", + "integrity": "sha512-HUFut4ztcVNmqy9gp/wxNbC7pTOHhgVVkHVGCACTuLhUKUhKAF9KYHJtMiLUJxEqiFLQiuri1fWF8zqwM/cu1w==", "dependencies": { - "@algolia/autocomplete-core": "1.7.1", - "@algolia/autocomplete-preset-algolia": "1.7.1", - "@docsearch/css": "3.1.1", - "algoliasearch": "^4.0.0" + "@algolia/autocomplete-core": "1.9.3", + "@algolia/autocomplete-preset-algolia": "1.9.3", + "@docsearch/css": "3.6.0", + "algoliasearch": "^4.19.1" }, "peerDependencies": { "@types/react": ">= 16.8.0 < 19.0.0", "react": ">= 16.8.0 < 19.0.0", - "react-dom": ">= 16.8.0 < 19.0.0" + "react-dom": ">= 16.8.0 < 19.0.0", + "search-insights": ">= 1 < 3" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "react": { + "optional": true + }, + "react-dom": { + "optional": true + }, + "search-insights": { + "optional": true + } } }, "node_modules/@docusaurus/core": { @@ -2413,14 +2656,14 @@ } }, "node_modules/@docusaurus/theme-live-codeblock": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/theme-live-codeblock/-/theme-live-codeblock-2.0.0-rc.1.tgz", - "integrity": "sha512-Sak7ZmznJIdTVConB1WQeGa9vQsCgkglPO6epqCTBHmfakEl9BHTBK+X/zoj7fWeX1DxD5UQ9/DiU8LAaIjLyA==", - "dependencies": { - "@docusaurus/core": "2.0.0-rc.1", - "@docusaurus/theme-common": "2.0.0-rc.1", - "@docusaurus/theme-translations": "2.0.0-rc.1", - "@docusaurus/utils-validation": "2.0.0-rc.1", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/theme-live-codeblock/-/theme-live-codeblock-2.4.3.tgz", + "integrity": "sha512-wx+iJCCoSewUkMzFy7pnbhDBCRcJRTLkpx1/zwnHhfiNWVvJ2XjtBKIviRyMhynZYyvO4sLTpCclzK8JOctkxw==", + "dependencies": { + "@docusaurus/core": "2.4.3", + "@docusaurus/theme-common": "2.4.3", + "@docusaurus/theme-translations": "2.4.3", + "@docusaurus/utils-validation": "2.4.3", "@philpl/buble": "^0.19.7", "clsx": "^1.2.1", "fs-extra": "^10.1.0", @@ -2436,9 +2679,9 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/core": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/core/-/core-2.0.0-rc.1.tgz", - "integrity": "sha512-b9FX0Z+EddfQ6wAiNh+Wx4fysKfcvEcWJrZ5USROn3C+EVU5P4luaa8mwWK//O+hTwD9ur7/A44IZ/tWCTAoLQ==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/core/-/core-2.4.3.tgz", + "integrity": "sha512-dWH5P7cgeNSIg9ufReX6gaCl/TmrGKD38Orbwuz05WPhAQtFXHd5B8Qym1TiXfvUNvwoYKkAJOJuGe8ou0Z7PA==", "dependencies": { "@babel/core": "^7.18.6", "@babel/generator": "^7.18.7", @@ -2450,13 +2693,13 @@ "@babel/runtime": "^7.18.6", "@babel/runtime-corejs3": "^7.18.6", "@babel/traverse": "^7.18.8", - "@docusaurus/cssnano-preset": "2.0.0-rc.1", - "@docusaurus/logger": "2.0.0-rc.1", - "@docusaurus/mdx-loader": "2.0.0-rc.1", + "@docusaurus/cssnano-preset": "2.4.3", + "@docusaurus/logger": "2.4.3", + "@docusaurus/mdx-loader": "2.4.3", "@docusaurus/react-loadable": "5.5.2", - "@docusaurus/utils": "2.0.0-rc.1", - "@docusaurus/utils-common": "2.0.0-rc.1", - "@docusaurus/utils-validation": "2.0.0-rc.1", + "@docusaurus/utils": "2.4.3", + "@docusaurus/utils-common": "2.4.3", + "@docusaurus/utils-validation": "2.4.3", "@slorber/static-site-generator-webpack-plugin": "^4.0.7", "@svgr/webpack": "^6.2.1", "autoprefixer": "^10.4.7", @@ -2477,7 +2720,7 @@ "del": "^6.1.1", "detect-port": "^1.3.0", "escape-html": "^1.0.3", - "eta": "^1.12.3", + "eta": "^2.0.0", "file-loader": "^6.2.0", "fs-extra": "^10.1.0", "html-minifier-terser": "^6.1.0", @@ -2524,9 +2767,9 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/cssnano-preset": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/cssnano-preset/-/cssnano-preset-2.0.0-rc.1.tgz", - "integrity": "sha512-9/KmQvF+eTlMqUqG6UcXbRgxbGed/8bQInXuKEs+95/jI6jO/3xSzuRwuHHHP0naUvSVWjnNI9jngPrQerXE5w==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/cssnano-preset/-/cssnano-preset-2.4.3.tgz", + "integrity": "sha512-ZvGSRCi7z9wLnZrXNPG6DmVPHdKGd8dIn9pYbEOFiYihfv4uDR3UtxogmKf+rT8ZlKFf5Lqne8E8nt08zNM8CA==", "dependencies": { "cssnano-preset-advanced": "^5.3.8", "postcss": "^8.4.14", @@ -2538,9 +2781,9 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/logger": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/logger/-/logger-2.0.0-rc.1.tgz", - "integrity": "sha512-daa3g+SXuO9K60PVMiSUmDEK9Vro+Ed7i7uF8CH6QQJLcNZy/zJc0Xz62eH7ip1x77fmeb6Rg4Us1TqTFc9AbQ==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/logger/-/logger-2.4.3.tgz", + "integrity": "sha512-Zxws7r3yLufk9xM1zq9ged0YHs65mlRmtsobnFkdZTxWXdTYlWWLWdKyNKAsVC+D7zg+pv2fGbyabdOnyZOM3w==", "dependencies": { "chalk": "^4.1.2", "tslib": "^2.4.0" @@ -2550,14 +2793,14 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/mdx-loader": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/mdx-loader/-/mdx-loader-2.0.0-rc.1.tgz", - "integrity": "sha512-8Fg0c/ceu39knmr7w0dutm7gq3YxKYCqWVS2cB/cPATzChCCNH/AGLfBT6sz/Z4tjVXE+NyREq2pfOFvkhjVXg==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/mdx-loader/-/mdx-loader-2.4.3.tgz", + "integrity": "sha512-b1+fDnWtl3GiqkL0BRjYtc94FZrcDDBV1j8446+4tptB9BAOlePwG2p/pK6vGvfL53lkOsszXMghr2g67M0vCw==", "dependencies": { "@babel/parser": "^7.18.8", "@babel/traverse": "^7.18.8", - "@docusaurus/logger": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", + "@docusaurus/logger": "2.4.3", + "@docusaurus/utils": "2.4.3", "@mdx-js/mdx": "^1.6.22", "escape-html": "^1.0.3", "file-loader": "^6.2.0", @@ -2581,12 +2824,12 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/module-type-aliases": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/module-type-aliases/-/module-type-aliases-2.0.0-rc.1.tgz", - "integrity": "sha512-la7D8ggFP8I5nOp/Epl6NqTeDWcbofPVMOaVisRxQbx5iuF9Al+AITbaDgm4CXpFLJACsqhsXD5W4BnKX8ZxfA==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/module-type-aliases/-/module-type-aliases-2.4.3.tgz", + "integrity": "sha512-cwkBkt1UCiduuvEAo7XZY01dJfRn7UR/75mBgOdb1hKknhrabJZ8YH+7savd/y9kLExPyrhe0QwdS9GuzsRRIA==", "dependencies": { "@docusaurus/react-loadable": "5.5.2", - "@docusaurus/types": "2.0.0-rc.1", + "@docusaurus/types": "2.4.3", "@types/history": "^4.7.11", "@types/react": "*", "@types/react-router-config": "*", @@ -2600,17 +2843,17 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/plugin-content-blog": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-blog/-/plugin-content-blog-2.0.0-rc.1.tgz", - "integrity": "sha512-BVVrAGZujpjS/0rarY2o24rlylRRh2NZuM65kg0JNkkViF79SeEHsepog7IuHyoqGWPm1N/I7LpEp7k+gowZzQ==", - "dependencies": { - "@docusaurus/core": "2.0.0-rc.1", - "@docusaurus/logger": "2.0.0-rc.1", - "@docusaurus/mdx-loader": "2.0.0-rc.1", - "@docusaurus/types": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", - "@docusaurus/utils-common": "2.0.0-rc.1", - "@docusaurus/utils-validation": "2.0.0-rc.1", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-blog/-/plugin-content-blog-2.4.3.tgz", + "integrity": "sha512-PVhypqaA0t98zVDpOeTqWUTvRqCEjJubtfFUQ7zJNYdbYTbS/E/ytq6zbLVsN/dImvemtO/5JQgjLxsh8XLo8Q==", + "dependencies": { + "@docusaurus/core": "2.4.3", + "@docusaurus/logger": "2.4.3", + "@docusaurus/mdx-loader": "2.4.3", + "@docusaurus/types": "2.4.3", + "@docusaurus/utils": "2.4.3", + "@docusaurus/utils-common": "2.4.3", + "@docusaurus/utils-validation": "2.4.3", "cheerio": "^1.0.0-rc.12", "feed": "^4.2.2", "fs-extra": "^10.1.0", @@ -2630,17 +2873,17 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/plugin-content-docs": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-2.0.0-rc.1.tgz", - "integrity": "sha512-Yk5Hu6uaw3tRplzJnbDygwRhmZ3PCzEXD4SJpBA6cPC73ylfqOEh6qhiU+BWhMTtDXNhY+athk5Kycfk3DW1aQ==", - "dependencies": { - "@docusaurus/core": "2.0.0-rc.1", - "@docusaurus/logger": "2.0.0-rc.1", - "@docusaurus/mdx-loader": "2.0.0-rc.1", - "@docusaurus/module-type-aliases": "2.0.0-rc.1", - "@docusaurus/types": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", - "@docusaurus/utils-validation": "2.0.0-rc.1", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-2.4.3.tgz", + "integrity": "sha512-N7Po2LSH6UejQhzTCsvuX5NOzlC+HiXOVvofnEPj0WhMu1etpLEXE6a4aTxrtg95lQ5kf0xUIdjX9sh3d3G76A==", + "dependencies": { + "@docusaurus/core": "2.4.3", + "@docusaurus/logger": "2.4.3", + "@docusaurus/mdx-loader": "2.4.3", + "@docusaurus/module-type-aliases": "2.4.3", + "@docusaurus/types": "2.4.3", + "@docusaurus/utils": "2.4.3", + "@docusaurus/utils-validation": "2.4.3", "@types/react-router-config": "^5.0.6", "combine-promises": "^1.1.0", "fs-extra": "^10.1.0", @@ -2660,15 +2903,15 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/plugin-content-pages": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-pages/-/plugin-content-pages-2.0.0-rc.1.tgz", - "integrity": "sha512-FdO79WC5hfWDQu3/CTFLRQzTNc0e5n+HNzavm2MNkSzGV08BFJ6RAkbPbtra5CWef+6iXZav6D/tzv2jDPvLzA==", - "dependencies": { - "@docusaurus/core": "2.0.0-rc.1", - "@docusaurus/mdx-loader": "2.0.0-rc.1", - "@docusaurus/types": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", - "@docusaurus/utils-validation": "2.0.0-rc.1", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-pages/-/plugin-content-pages-2.4.3.tgz", + "integrity": "sha512-txtDVz7y3zGk67q0HjG0gRttVPodkHqE0bpJ+7dOaTH40CQFLSh7+aBeGnPOTl+oCPG+hxkim4SndqPqXjQ8Bg==", + "dependencies": { + "@docusaurus/core": "2.4.3", + "@docusaurus/mdx-loader": "2.4.3", + "@docusaurus/types": "2.4.3", + "@docusaurus/utils": "2.4.3", + "@docusaurus/utils-validation": "2.4.3", "fs-extra": "^10.1.0", "tslib": "^2.4.0", "webpack": "^5.73.0" @@ -2682,16 +2925,17 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/theme-common": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/theme-common/-/theme-common-2.0.0-rc.1.tgz", - "integrity": "sha512-1r9ZLKD9SeoCYVzWzcdR79Dia4ANlrlRjNl6uzETOEybjK6FF7yEa9Yra8EJcOCbi3coyYz5xFh/r1YHFTFHug==", - "dependencies": { - "@docusaurus/mdx-loader": "2.0.0-rc.1", - "@docusaurus/module-type-aliases": "2.0.0-rc.1", - "@docusaurus/plugin-content-blog": "2.0.0-rc.1", - "@docusaurus/plugin-content-docs": "2.0.0-rc.1", - "@docusaurus/plugin-content-pages": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/theme-common/-/theme-common-2.4.3.tgz", + "integrity": "sha512-7KaDJBXKBVGXw5WOVt84FtN8czGWhM0lbyWEZXGp8AFfL6sZQfRTluFp4QriR97qwzSyOfQb+nzcDZZU4tezUw==", + "dependencies": { + "@docusaurus/mdx-loader": "2.4.3", + "@docusaurus/module-type-aliases": "2.4.3", + "@docusaurus/plugin-content-blog": "2.4.3", + "@docusaurus/plugin-content-docs": "2.4.3", + "@docusaurus/plugin-content-pages": "2.4.3", + "@docusaurus/utils": "2.4.3", + "@docusaurus/utils-common": "2.4.3", "@types/history": "^4.7.11", "@types/react": "*", "@types/react-router-config": "*", @@ -2699,6 +2943,7 @@ "parse-numeric-range": "^1.3.0", "prism-react-renderer": "^1.3.5", "tslib": "^2.4.0", + "use-sync-external-store": "^1.2.0", "utility-types": "^3.10.0" }, "engines": { @@ -2710,9 +2955,9 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/theme-translations": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/theme-translations/-/theme-translations-2.0.0-rc.1.tgz", - "integrity": "sha512-JLhNdlnbQhxVQzOnLyiCaTzKFa1lpVrM3nCrkGQKscoG2rY6ARGYMgMN2DkoH6hm7TflQ8+PE1S5MzzASeLs4Q==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/theme-translations/-/theme-translations-2.4.3.tgz", + "integrity": "sha512-H4D+lbZbjbKNS/Zw1Lel64PioUAIT3cLYYJLUf3KkuO/oc9e0QCVhIYVtUI2SfBCF2NNdlyhBDQEEMygsCedIg==", "dependencies": { "fs-extra": "^10.1.0", "tslib": "^2.4.0" @@ -2722,9 +2967,9 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/types": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/types/-/types-2.0.0-rc.1.tgz", - "integrity": "sha512-wX25FOZa/aKnCGA5ljWPaDpMW3TuTbs0BtjQ8WTC557p8zDvuz4r+g2/FPHsgWE0TKwUMf4usQU1m3XpJLPN+g==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/types/-/types-2.4.3.tgz", + "integrity": "sha512-W6zNLGQqfrp/EoPD0bhb9n7OobP+RHpmvVzpA+Z/IuU3Q63njJM24hmT0GYboovWcDtFmnIJC9wcyx4RVPQscw==", "dependencies": { "@types/history": "^4.7.11", "@types/react": "*", @@ -2741,12 +2986,13 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/utils": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/utils/-/utils-2.0.0-rc.1.tgz", - "integrity": "sha512-ym9I1OwIYbKs1LGaUajaA/vDG8VweJj/6YoZjHp+eDQHhTRIrHXiYoGDqorafRhftKwnA1EnyomuXpNd9bq8Gg==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/utils/-/utils-2.4.3.tgz", + "integrity": "sha512-fKcXsjrD86Smxv8Pt0TBFqYieZZCPh4cbf9oszUq/AMhZn3ujwpKaVYZACPX8mmjtYx0JOgNx52CREBfiGQB4A==", "dependencies": { - "@docusaurus/logger": "2.0.0-rc.1", + "@docusaurus/logger": "2.4.3", "@svgr/webpack": "^6.2.1", + "escape-string-regexp": "^4.0.0", "file-loader": "^6.2.0", "fs-extra": "^10.1.0", "github-slugger": "^1.4.0", @@ -2774,9 +3020,9 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/utils-common": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/utils-common/-/utils-common-2.0.0-rc.1.tgz", - "integrity": "sha512-+iZICpeFPZJ9oGJXuG92WTWee6WRnVx5BdzlcfuKf/f5KQX8PvwXR2tDME78FGGhShB8zr+vjuNEXuLvXT7j2A==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/utils-common/-/utils-common-2.4.3.tgz", + "integrity": "sha512-/jascp4GbLQCPVmcGkPzEQjNaAk3ADVfMtudk49Ggb+131B1WDD6HqlSmDf8MxGdy7Dja2gc+StHf01kiWoTDQ==", "dependencies": { "tslib": "^2.4.0" }, @@ -2793,12 +3039,12 @@ } }, "node_modules/@docusaurus/theme-live-codeblock/node_modules/@docusaurus/utils-validation": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/utils-validation/-/utils-validation-2.0.0-rc.1.tgz", - "integrity": "sha512-lj36gm9Ksu4tt/EUeLDWoMbXe3sfBxeIPIUUdqYcBYkF/rpQkh+uL/dncjNGiw6uvBOqXhOfsFVP045HtgShVw==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/utils-validation/-/utils-validation-2.4.3.tgz", + "integrity": "sha512-G2+Vt3WR5E/9drAobP+hhZQMaswRwDlp6qOMi7o7ZypB+VO7N//DZWhZEwhcRGepMDJGQEwtPv7UxtYwPL9PBw==", "dependencies": { - "@docusaurus/logger": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", + "@docusaurus/logger": "2.4.3", + "@docusaurus/utils": "2.4.3", "joi": "^17.6.0", "js-yaml": "^4.1.0", "tslib": "^2.4.0" @@ -2807,6 +3053,17 @@ "node": ">=16.14" } }, + "node_modules/@docusaurus/theme-live-codeblock/node_modules/eta": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/eta/-/eta-2.2.0.tgz", + "integrity": "sha512-UVQ72Rqjy/ZKQalzV5dCCJP80GrmPrMxh6NlNf+erV6ObL0ZFkhCstWRawS85z3smdr3d2wXPsZEY7rDPfGd2g==", + "engines": { + "node": ">=6.0.0" + }, + "funding": { + "url": "https://github.com/eta-dev/eta?sponsor=1" + } + }, "node_modules/@docusaurus/theme-search-algolia": { "version": "2.0.0-beta.22", "resolved": "https://registry.npmjs.org/@docusaurus/theme-search-algolia/-/theme-search-algolia-2.0.0-beta.22.tgz", @@ -2948,6 +3205,33 @@ "@hapi/hoek": "^9.0.0" } }, + "node_modules/@jest/schemas": { + "version": "29.6.3", + "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz", + "integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==", + "dependencies": { + "@sinclair/typebox": "^0.27.8" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/types": { + "version": "29.6.3", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-29.6.3.tgz", + "integrity": "sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==", + "dependencies": { + "@jest/schemas": "^29.6.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, "node_modules/@jridgewell/gen-mapping": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz", @@ -2977,18 +3261,18 @@ } }, "node_modules/@jridgewell/source-map": { - "version": "0.3.2", - "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz", - "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==", + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.5.tgz", + "integrity": "sha512-UTYAUj/wviwdsMfzoSJspJxbkH5o1snzwX0//0ENX1u/55kkZZkcTZP6u9bwKGkv+dkk9at4m1Cpt0uY80kcpQ==", "dependencies": { "@jridgewell/gen-mapping": "^0.3.0", "@jridgewell/trace-mapping": "^0.3.9" } }, "node_modules/@jridgewell/source-map/node_modules/@jridgewell/gen-mapping": { - "version": "0.3.2", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz", - "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==", + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz", + "integrity": "sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==", "dependencies": { "@jridgewell/set-array": "^1.0.1", "@jridgewell/sourcemap-codec": "^1.4.10", @@ -3004,12 +3288,12 @@ "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==" }, "node_modules/@jridgewell/trace-mapping": { - "version": "0.3.14", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.14.tgz", - "integrity": "sha512-bJWEfQ9lPTvm3SneWwRFVLzrh6nhjwqw7TUFFBEMzwvg7t7PCDenf2lDwqo4NQXzdpgBXyFgDWnQA+2vkruksQ==", + "version": "0.3.20", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.20.tgz", + "integrity": "sha512-R8LcPeWZol2zR8mmH3JeKQ6QRCFb7XgUhV9ZlGhHLGyg4wpPiPZNQOOWhFZhxKw8u//yTbNGI42Bx/3paXEQ+Q==", "dependencies": { - "@jridgewell/resolve-uri": "^3.0.3", - "@jridgewell/sourcemap-codec": "^1.4.10" + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" } }, "node_modules/@leichtgewicht/ip-codec": { @@ -3088,10 +3372,23 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/@mdx-js/mdx/node_modules/convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==" + }, + "node_modules/@mdx-js/mdx/node_modules/is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "engines": { + "node": ">=8" + } + }, "node_modules/@mdx-js/mdx/node_modules/semver": { - "version": "5.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", - "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", + "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", "bin": { "semver": "bin/semver" } @@ -3281,11 +3578,6 @@ "node": ">=4" } }, - "node_modules/@philpl/buble/node_modules/regjsgen": { - "version": "0.5.2", - "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.2.tgz", - "integrity": "sha512-OFFT3MfrH90xIW8OOSyUrk6QHD5E9JOTeGodiJeBS3J6IwlgzJMNE/1bZklWz5oTg+9dCMyEetclvCVXOPoN3A==" - }, "node_modules/@philpl/buble/node_modules/regjsparser": { "version": "0.7.0", "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.7.0.tgz", @@ -3309,9 +3601,9 @@ } }, "node_modules/@polka/url": { - "version": "1.0.0-next.21", - "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.21.tgz", - "integrity": "sha512-a5Sab1C4/icpTZVzZc5Ghpz88yQtGOyNqYXcZgOssB2uuAr+wF/MvN6bgtW32q7HHrvBki+BsZ0OuNv6EV3K9g==" + "version": "1.0.0-next.23", + "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.23.tgz", + "integrity": "sha512-C16M+IYz0rgRhWZdCmK+h58JMv8vijAA61gmz2rspCSwKwzBebpdcsiUmwrtJRdphuY30i6BSLEOP8ppbNLyLg==" }, "node_modules/@sideway/address": { "version": "4.1.4", @@ -3331,6 +3623,11 @@ "resolved": "https://registry.npmjs.org/@sideway/pinpoint/-/pinpoint-2.0.0.tgz", "integrity": "sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ==" }, + "node_modules/@sinclair/typebox": { + "version": "0.27.8", + "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz", + "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==" + }, "node_modules/@sindresorhus/is": { "version": "0.14.0", "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.14.0.tgz", @@ -3353,9 +3650,9 @@ } }, "node_modules/@svgr/babel-plugin-add-jsx-attribute": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-6.0.0.tgz", - "integrity": "sha512-MdPdhdWLtQsjd29Wa4pABdhWbaRMACdM1h31BY+c6FghTZqNGT7pEYdBoaGeKtdTOBC/XNFQaKVj+r/Ei2ryWA==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-6.5.1.tgz", + "integrity": "sha512-9PYGcXrAxitycIjRmZB+Q0JaN07GZIWaTBIGQzfaZv+qr1n8X1XUEJ5rZ/vx6OVD9RRYlrNnXWExQXcmZeD/BQ==", "engines": { "node": ">=10" }, @@ -3368,11 +3665,11 @@ } }, "node_modules/@svgr/babel-plugin-remove-jsx-attribute": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-6.0.0.tgz", - "integrity": "sha512-aVdtfx9jlaaxc3unA6l+M9YRnKIZjOhQPthLKqmTXC8UVkBLDRGwPKo+r8n3VZN8B34+yVajzPTZ+ptTSuZZCw==", + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-8.0.0.tgz", + "integrity": "sha512-BcCkm/STipKvbCl6b7QFrMh/vx00vIP63k2eM66MfHJzPr6O2U0jYEViXkHJWqXqQYjdeA9cuCl5KWmlwjDvbA==", "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3383,11 +3680,11 @@ } }, "node_modules/@svgr/babel-plugin-remove-jsx-empty-expression": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-6.0.0.tgz", - "integrity": "sha512-Ccj42ApsePD451AZJJf1QzTD1B/BOU392URJTeXFxSK709i0KUsGtbwyiqsKu7vsYxpTM0IA5clAKDyf9RCZyA==", + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-8.0.0.tgz", + "integrity": "sha512-5BcGCBfBxB5+XSDSWnhTThfI9jcO5f0Ai2V24gZpG+wXF14BzwxxdDb4g6trdOux0rhibGs385BeFMSmxtS3uA==", "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3398,9 +3695,9 @@ } }, "node_modules/@svgr/babel-plugin-replace-jsx-attribute-value": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-6.0.0.tgz", - "integrity": "sha512-88V26WGyt1Sfd1emBYmBJRWMmgarrExpKNVmI9vVozha4kqs6FzQJ/Kp5+EYli1apgX44518/0+t9+NU36lThQ==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-6.5.1.tgz", + "integrity": "sha512-8DPaVVE3fd5JKuIC29dqyMB54sA6mfgki2H2+swh+zNJoynC8pMPzOkidqHOSc6Wj032fhl8Z0TVn1GiPpAiJg==", "engines": { "node": ">=10" }, @@ -3413,9 +3710,9 @@ } }, "node_modules/@svgr/babel-plugin-svg-dynamic-title": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-6.0.0.tgz", - "integrity": "sha512-F7YXNLfGze+xv0KMQxrl2vkNbI9kzT9oDK55/kUuymh1ACyXkMV+VZWX1zEhSTfEKh7VkHVZGmVtHg8eTZ6PRg==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-6.5.1.tgz", + "integrity": "sha512-FwOEi0Il72iAzlkaHrlemVurgSQRDFbk0OC8dSvD5fSBPHltNh7JtLsxmZUhjYBZo2PpcU/RJvvi6Q0l7O7ogw==", "engines": { "node": ">=10" }, @@ -3428,9 +3725,9 @@ } }, "node_modules/@svgr/babel-plugin-svg-em-dimensions": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-6.0.0.tgz", - "integrity": "sha512-+rghFXxdIqJNLQK08kwPBD3Z22/0b2tEZ9lKiL/yTfuyj1wW8HUXu4bo/XkogATIYuXSghVQOOCwURXzHGKyZA==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-6.5.1.tgz", + "integrity": "sha512-gWGsiwjb4tw+ITOJ86ndY/DZZ6cuXMNE/SjcDRg+HLuCmwpcjOktwRF9WgAiycTqJD/QXqL2f8IzE2Rzh7aVXA==", "engines": { "node": ">=10" }, @@ -3443,9 +3740,9 @@ } }, "node_modules/@svgr/babel-plugin-transform-react-native-svg": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-6.0.0.tgz", - "integrity": "sha512-VaphyHZ+xIKv5v0K0HCzyfAaLhPGJXSk2HkpYfXIOKb7DjLBv0soHDxNv6X0vr2titsxE7klb++u7iOf7TSrFQ==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-6.5.1.tgz", + "integrity": "sha512-2jT3nTayyYP7kI6aGutkyfJ7UMGtuguD72OjeGLwVNyfPRBD8zQthlvL+fAbAKk5n9ZNcvFkp/b1lZ7VsYqVJg==", "engines": { "node": ">=10" }, @@ -3458,9 +3755,9 @@ } }, "node_modules/@svgr/babel-plugin-transform-svg-component": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-6.2.0.tgz", - "integrity": "sha512-bhYIpsORb++wpsp91fymbFkf09Z/YEKR0DnFjxvN+8JHeCUD2unnh18jIMKnDJTWtvpTaGYPXELVe4OOzFI0xg==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-6.5.1.tgz", + "integrity": "sha512-a1p6LF5Jt33O3rZoVRBqdxL350oge54iZWHNI6LJB5tQ7EelvD/Mb1mfBiZNAan0dt4i3VArkFRjA4iObuNykQ==", "engines": { "node": ">=12" }, @@ -3473,18 +3770,18 @@ } }, "node_modules/@svgr/babel-preset": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-preset/-/babel-preset-6.2.0.tgz", - "integrity": "sha512-4WQNY0J71JIaL03DRn0vLiz87JXx0b9dYm2aA8XHlQJQoixMl4r/soYHm8dsaJZ3jWtkCiOYy48dp9izvXhDkQ==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-preset/-/babel-preset-6.5.1.tgz", + "integrity": "sha512-6127fvO/FF2oi5EzSQOAjo1LE3OtNVh11R+/8FXa+mHx1ptAaS4cknIjnUA7e6j6fwGGJ17NzaTJFUwOV2zwCw==", "dependencies": { - "@svgr/babel-plugin-add-jsx-attribute": "^6.0.0", - "@svgr/babel-plugin-remove-jsx-attribute": "^6.0.0", - "@svgr/babel-plugin-remove-jsx-empty-expression": "^6.0.0", - "@svgr/babel-plugin-replace-jsx-attribute-value": "^6.0.0", - "@svgr/babel-plugin-svg-dynamic-title": "^6.0.0", - "@svgr/babel-plugin-svg-em-dimensions": "^6.0.0", - "@svgr/babel-plugin-transform-react-native-svg": "^6.0.0", - "@svgr/babel-plugin-transform-svg-component": "^6.2.0" + "@svgr/babel-plugin-add-jsx-attribute": "^6.5.1", + "@svgr/babel-plugin-remove-jsx-attribute": "*", + "@svgr/babel-plugin-remove-jsx-empty-expression": "*", + "@svgr/babel-plugin-replace-jsx-attribute-value": "^6.5.1", + "@svgr/babel-plugin-svg-dynamic-title": "^6.5.1", + "@svgr/babel-plugin-svg-em-dimensions": "^6.5.1", + "@svgr/babel-plugin-transform-react-native-svg": "^6.5.1", + "@svgr/babel-plugin-transform-svg-component": "^6.5.1" }, "engines": { "node": ">=10" @@ -3498,11 +3795,13 @@ } }, "node_modules/@svgr/core": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/@svgr/core/-/core-6.2.1.tgz", - "integrity": "sha512-NWufjGI2WUyrg46mKuySfviEJ6IxHUOm/8a3Ph38VCWSp+83HBraCQrpEM3F3dB6LBs5x8OElS8h3C0oOJaJAA==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/core/-/core-6.5.1.tgz", + "integrity": "sha512-/xdLSWxK5QkqG524ONSjvg3V/FkNyCv538OIBdQqPNaAta3AsXj/Bd2FbvR87yMbXO2hFSWiAe/Q6IkVPDw+mw==", "dependencies": { - "@svgr/plugin-jsx": "^6.2.1", + "@babel/core": "^7.19.6", + "@svgr/babel-preset": "^6.5.1", + "@svgr/plugin-jsx": "^6.5.1", "camelcase": "^6.2.0", "cosmiconfig": "^7.0.1" }, @@ -3515,12 +3814,12 @@ } }, "node_modules/@svgr/hast-util-to-babel-ast": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-6.2.1.tgz", - "integrity": "sha512-pt7MMkQFDlWJVy9ULJ1h+hZBDGFfSCwlBNW1HkLnVi7jUhyEXUaGYWi1x6bM2IXuAR9l265khBT4Av4lPmaNLQ==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-6.5.1.tgz", + "integrity": "sha512-1hnUxxjd83EAxbL4a0JDJoD3Dao3hmjvyvyEV8PzWmLK3B9m9NPlW7GKjFyoWE8nM7HnXzPcmmSyOW8yOddSXw==", "dependencies": { - "@babel/types": "^7.15.6", - "entities": "^3.0.1" + "@babel/types": "^7.20.0", + "entities": "^4.4.0" }, "engines": { "node": ">=10" @@ -3531,14 +3830,14 @@ } }, "node_modules/@svgr/plugin-jsx": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/@svgr/plugin-jsx/-/plugin-jsx-6.2.1.tgz", - "integrity": "sha512-u+MpjTsLaKo6r3pHeeSVsh9hmGRag2L7VzApWIaS8imNguqoUwDq/u6U/NDmYs/KAsrmtBjOEaAAPbwNGXXp1g==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/plugin-jsx/-/plugin-jsx-6.5.1.tgz", + "integrity": "sha512-+UdQxI3jgtSjCykNSlEMuy1jSRQlGC7pqBCPvkG/2dATdWo082zHTTK3uhnAju2/6XpE6B5mZ3z4Z8Ns01S8Gw==", "dependencies": { - "@babel/core": "^7.15.5", - "@svgr/babel-preset": "^6.2.0", - "@svgr/hast-util-to-babel-ast": "^6.2.1", - "svg-parser": "^2.0.2" + "@babel/core": "^7.19.6", + "@svgr/babel-preset": "^6.5.1", + "@svgr/hast-util-to-babel-ast": "^6.5.1", + "svg-parser": "^2.0.4" }, "engines": { "node": ">=10" @@ -3552,13 +3851,13 @@ } }, "node_modules/@svgr/plugin-svgo": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/@svgr/plugin-svgo/-/plugin-svgo-6.2.0.tgz", - "integrity": "sha512-oDdMQONKOJEbuKwuy4Np6VdV6qoaLLvoY86hjvQEgU82Vx1MSWRyYms6Sl0f+NtqxLI/rDVufATbP/ev996k3Q==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/plugin-svgo/-/plugin-svgo-6.5.1.tgz", + "integrity": "sha512-omvZKf8ixP9z6GWgwbtmP9qQMPX4ODXi+wzbVZgomNFsUIlHA1sf4fThdwTWSsZGgvGAG6yE+b/F5gWUkcZ/iQ==", "dependencies": { "cosmiconfig": "^7.0.1", "deepmerge": "^4.2.2", - "svgo": "^2.5.0" + "svgo": "^2.8.0" }, "engines": { "node": ">=10" @@ -3568,22 +3867,22 @@ "url": "https://github.com/sponsors/gregberge" }, "peerDependencies": { - "@svgr/core": "^6.0.0" + "@svgr/core": "*" } }, "node_modules/@svgr/webpack": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/@svgr/webpack/-/webpack-6.2.1.tgz", - "integrity": "sha512-h09ngMNd13hnePwgXa+Y5CgOjzlCvfWLHg+MBnydEedAnuLRzUHUJmGS3o2OsrhxTOOqEsPOFt5v/f6C5Qulcw==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/webpack/-/webpack-6.5.1.tgz", + "integrity": "sha512-cQ/AsnBkXPkEK8cLbv4Dm7JGXq2XrumKnL1dRpJD9rIO2fTIlJI9a1uCciYG1F2aUsox/hJQyNGbt3soDxSRkA==", "dependencies": { - "@babel/core": "^7.15.5", - "@babel/plugin-transform-react-constant-elements": "^7.14.5", - "@babel/preset-env": "^7.15.6", - "@babel/preset-react": "^7.14.5", - "@babel/preset-typescript": "^7.15.0", - "@svgr/core": "^6.2.1", - "@svgr/plugin-jsx": "^6.2.1", - "@svgr/plugin-svgo": "^6.2.0" + "@babel/core": "^7.19.6", + "@babel/plugin-transform-react-constant-elements": "^7.18.12", + "@babel/preset-env": "^7.19.4", + "@babel/preset-react": "^7.18.6", + "@babel/preset-typescript": "^7.18.6", + "@svgr/core": "^6.5.1", + "@svgr/plugin-jsx": "^6.5.1", + "@svgr/plugin-svgo": "^6.5.1" }, "engines": { "node": ">=10" @@ -3613,89 +3912,72 @@ } }, "node_modules/@types/body-parser": { - "version": "1.19.2", - "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.2.tgz", - "integrity": "sha512-ALYone6pm6QmwZoAgeyNksccT9Q4AWZQ6PvfwR37GT6r6FWUPguq6sUmNGSMV2Wr761oQoBxwGGa6DR5o1DC9g==", + "version": "1.19.5", + "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz", + "integrity": "sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==", "dependencies": { "@types/connect": "*", "@types/node": "*" } }, "node_modules/@types/bonjour": { - "version": "3.5.10", - "resolved": "https://registry.npmjs.org/@types/bonjour/-/bonjour-3.5.10.tgz", - "integrity": "sha512-p7ienRMiS41Nu2/igbJxxLDWrSZ0WxM8UQgCeO9KhoVF7cOVFkrKsiDr1EsJIla8vV3oEEjGcz11jc5yimhzZw==", + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@types/bonjour/-/bonjour-3.5.13.tgz", + "integrity": "sha512-z9fJ5Im06zvUL548KvYNecEVlA7cVDkGUi6kZusb04mpyEFKCIZJvloCcmpmLaIahDpOQGHaHmG6imtPMmPXGQ==", "dependencies": { "@types/node": "*" } }, "node_modules/@types/connect": { - "version": "3.4.35", - "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.35.tgz", - "integrity": "sha512-cdeYyv4KWoEgpBISTxWvqYsVy444DOqehiF3fM3ne10AmJ62RSyNkUnxMJXHQWRQQX2eR94m5y1IZyDwBjV9FQ==", + "version": "3.4.38", + "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz", + "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==", "dependencies": { "@types/node": "*" } }, "node_modules/@types/connect-history-api-fallback": { - "version": "1.3.5", - "resolved": "https://registry.npmjs.org/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.3.5.tgz", - "integrity": "sha512-h8QJa8xSb1WD4fpKBDcATDNGXghFj6/3GRWG6dhmRcu0RX1Ubasur2Uvx5aeEwlf0MwblEC2bMzzMQntxnw/Cw==", + "version": "1.5.3", + "resolved": "https://registry.npmjs.org/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.5.3.tgz", + "integrity": "sha512-6mfQ6iNvhSKCZJoY6sIG3m0pKkdUcweVNOLuBBKvoWGzl2yRxOJcYOTRyLKt3nxXvBLJWa6QkW//tgbIwJehmA==", "dependencies": { "@types/express-serve-static-core": "*", "@types/node": "*" } }, - "node_modules/@types/eslint": { - "version": "8.4.5", - "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.4.5.tgz", - "integrity": "sha512-dhsC09y1gpJWnK+Ff4SGvCuSnk9DaU0BJZSzOwa6GVSg65XtTugLBITDAAzRU5duGBoXBHpdR/9jHGxJjNflJQ==", - "dependencies": { - "@types/estree": "*", - "@types/json-schema": "*" - } - }, - "node_modules/@types/eslint-scope": { - "version": "3.7.4", - "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.4.tgz", - "integrity": "sha512-9K4zoImiZc3HlIp6AVUDE4CWYx22a+lhSZMYNpbjW04+YF0KWj4pJXnEMjdnFTiQibFFmElcsasJXDbdI/EPhA==", - "dependencies": { - "@types/eslint": "*", - "@types/estree": "*" - } - }, "node_modules/@types/estree": { - "version": "0.0.51", - "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.51.tgz", - "integrity": "sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==" + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz", + "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==" }, "node_modules/@types/express": { - "version": "4.17.13", - "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.13.tgz", - "integrity": "sha512-6bSZTPaTIACxn48l50SR+axgrqm6qXFIxrdAKaG6PaJk3+zuUr35hBlgT7vOmJcum+OEaIBLtHV/qloEAFITeA==", + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.21.tgz", + "integrity": "sha512-ejlPM315qwLpaQlQDTjPdsUFSc6ZsP4AN6AlWnogPjQ7CVi7PYF3YVz+CY3jE2pwYf7E/7HlDAN0rV2GxTG0HQ==", "dependencies": { "@types/body-parser": "*", - "@types/express-serve-static-core": "^4.17.18", + "@types/express-serve-static-core": "^4.17.33", "@types/qs": "*", "@types/serve-static": "*" } }, "node_modules/@types/express-serve-static-core": { - "version": "4.17.29", - "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.17.29.tgz", - "integrity": "sha512-uMd++6dMKS32EOuw1Uli3e3BPgdLIXmezcfHv7N4c1s3gkhikBplORPpMq3fuWkxncZN1reb16d5n8yhQ80x7Q==", + "version": "4.17.41", + "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.17.41.tgz", + "integrity": "sha512-OaJ7XLaelTgrvlZD8/aa0vvvxZdUmlCn6MtWeB7TkiKW70BQLc9XEPpDLPdbo52ZhXUCrznlWdCHWxJWtdyajA==", "dependencies": { "@types/node": "*", "@types/qs": "*", - "@types/range-parser": "*" + "@types/range-parser": "*", + "@types/send": "*" } }, "node_modules/@types/hast": { - "version": "2.3.4", - "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.4.tgz", - "integrity": "sha512-wLEm0QvaoawEDoTRwzTXp4b4jpwiJDvR5KMnFnVodm3scufTlBOWRD6N1OBf9TZMhjlNsSfcO5V+7AF4+Vy+9g==", + "version": "2.3.10", + "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.10.tgz", + "integrity": "sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw==", "dependencies": { - "@types/unist": "*" + "@types/unist": "^2" } }, "node_modules/@types/history": { @@ -3708,37 +3990,71 @@ "resolved": "https://registry.npmjs.org/@types/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz", "integrity": "sha512-oh/6byDPnL1zeNXFrDXFLyZjkr1MsBG667IM792caf1L2UPOOMf65NFzjUH/ltyfwjAGfs1rsX1eftK0jC/KIg==" }, + "node_modules/@types/http-errors": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz", + "integrity": "sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==" + }, "node_modules/@types/http-proxy": { - "version": "1.17.9", - "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.9.tgz", - "integrity": "sha512-QsbSjA/fSk7xB+UXlCT3wHBy5ai9wOcNDWwZAtud+jXhwOM3l+EYZh8Lng4+/6n8uar0J7xILzqftJdJ/Wdfkw==", + "version": "1.17.14", + "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.14.tgz", + "integrity": "sha512-SSrD0c1OQzlFX7pGu1eXxSEjemej64aaNPRhhVYUGqXh0BtldAAx37MG8btcumvpgKyZp1F5Gn3JkktdxiFv6w==", "dependencies": { "@types/node": "*" } }, + "node_modules/@types/istanbul-lib-coverage": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz", + "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==" + }, + "node_modules/@types/istanbul-lib-report": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz", + "integrity": "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==", + "dependencies": { + "@types/istanbul-lib-coverage": "*" + } + }, + "node_modules/@types/istanbul-reports": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz", + "integrity": "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==", + "dependencies": { + "@types/istanbul-lib-report": "*" + } + }, "node_modules/@types/json-schema": { "version": "7.0.11", "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.11.tgz", "integrity": "sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==" }, "node_modules/@types/mdast": { - "version": "3.0.10", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.10.tgz", - "integrity": "sha512-W864tg/Osz1+9f4lrGTZpCSO5/z4608eUp19tbozkq2HJK6i3z1kT0H9tlADXuYIb1YYOBByU4Jsqkk75q48qA==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", "dependencies": { - "@types/unist": "*" + "@types/unist": "^2" } }, "node_modules/@types/mime": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.2.tgz", - "integrity": "sha512-YATxVxgRqNH6nHEIsvg6k2Boc1JHI9ZbH5iWFFv/MTkchz3b1ieGDa5T0a9RznNdI0KhVbdbWSN+KWWrQZRxTw==" + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz", + "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==" }, "node_modules/@types/node": { "version": "18.0.6", "resolved": "https://registry.npmjs.org/@types/node/-/node-18.0.6.tgz", "integrity": "sha512-/xUq6H2aQm261exT6iZTMifUySEt4GR5KX8eYyY+C4MSNPqSh9oNIP7tz2GLKTlFaiBbgZNxffoR3CVRG+cljw==" }, + "node_modules/@types/node-forge": { + "version": "1.3.9", + "resolved": "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.3.9.tgz", + "integrity": "sha512-meK88cx/sTalPSLSoCzkiUB4VPIFHmxtXm5FaaqRDqBX2i/Sy8bJ4odsan0b20RBjPh06dAQ+OTTdnyQyhJZyQ==", + "dependencies": { + "@types/node": "*" + } + }, "node_modules/@types/parse-json": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.0.tgz", @@ -3755,14 +4071,14 @@ "integrity": "sha512-JCB8C6SnDoQf0cNycqd/35A7MjcnK+ZTqE7judS6o7utxUCg6imJg3QK2qzHKszlTjcj2cn+NwMB2i96ubpj7w==" }, "node_modules/@types/qs": { - "version": "6.9.7", - "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.7.tgz", - "integrity": "sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw==" + "version": "6.9.10", + "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.10.tgz", + "integrity": "sha512-3Gnx08Ns1sEoCrWssEgTSJs/rsT2vhGP+Ja9cnnk9k4ALxinORlQneLXFeFKOTJMOeZUFD1s7w+w2AphTpvzZw==" }, "node_modules/@types/range-parser": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.4.tgz", - "integrity": "sha512-EEhsLsD6UsDM1yFhAvy0Cjr6VwmpMWqFBCb9w07wVugF7w9nfajxLuVmngTIpgS6svCnm6Vaw+MZhoDCKnOfsw==" + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz", + "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==" }, "node_modules/@types/react": { "version": "18.0.15", @@ -3784,13 +4100,13 @@ } }, "node_modules/@types/react-router-config": { - "version": "5.0.6", - "resolved": "https://registry.npmjs.org/@types/react-router-config/-/react-router-config-5.0.6.tgz", - "integrity": "sha512-db1mx37a1EJDf1XeX8jJN7R3PZABmJQXR8r28yUjVMFSjkmnQo6X6pOEEmNl+Tp2gYQOGPdYbFIipBtdElZ3Yg==", + "version": "5.0.10", + "resolved": "https://registry.npmjs.org/@types/react-router-config/-/react-router-config-5.0.10.tgz", + "integrity": "sha512-Wn6c/tXdEgi9adCMtDwx8Q2vGty6TsPTc/wCQQ9kAlye8UqFxj0vGFWWuhywNfkwqth+SOgJxQTLTZukrqDQmQ==", "dependencies": { "@types/history": "^4.7.11", "@types/react": "*", - "@types/react-router": "*" + "@types/react-router": "^5.1.0" } }, "node_modules/@types/react-router-dom": { @@ -3809,9 +4125,9 @@ "integrity": "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==" }, "node_modules/@types/sax": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/@types/sax/-/sax-1.2.4.tgz", - "integrity": "sha512-pSAff4IAxJjfAXUG6tFkO7dsSbTmf8CtUpfhhZ5VhkRpC4628tJhh3+V6H1E+/Gs9piSzYKT5yzHO5M4GG9jkw==", + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/@types/sax/-/sax-1.2.7.tgz", + "integrity": "sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A==", "dependencies": { "@types/node": "*" } @@ -3821,27 +4137,37 @@ "resolved": "https://registry.npmjs.org/@types/scheduler/-/scheduler-0.16.2.tgz", "integrity": "sha512-hppQEBDmlwhFAXKJX2KnWLYu5yMfi91yazPb2l+lbJiwW+wdo1gNeRA+3RgNSO39WYX2euey41KEwnqesU2Jew==" }, + "node_modules/@types/send": { + "version": "0.17.4", + "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.4.tgz", + "integrity": "sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==", + "dependencies": { + "@types/mime": "^1", + "@types/node": "*" + } + }, "node_modules/@types/serve-index": { - "version": "1.9.1", - "resolved": "https://registry.npmjs.org/@types/serve-index/-/serve-index-1.9.1.tgz", - "integrity": "sha512-d/Hs3nWDxNL2xAczmOVZNj92YZCS6RGxfBPjKzuu/XirCgXdpKEb88dYNbrYGint6IVWLNP+yonwVAuRC0T2Dg==", + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@types/serve-index/-/serve-index-1.9.4.tgz", + "integrity": "sha512-qLpGZ/c2fhSs5gnYsQxtDEq3Oy8SXPClIXkW5ghvAvsNuVSA8k+gCONcUCS/UjLEYvYps+e8uBtfgXgvhwfNug==", "dependencies": { "@types/express": "*" } }, "node_modules/@types/serve-static": { - "version": "1.13.10", - "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.13.10.tgz", - "integrity": "sha512-nCkHGI4w7ZgAdNkrEu0bv+4xNV/XDqW+DydknebMOQwkpDGx8G+HTlj7R7ABI8i8nKxVw0wtKPi1D+lPOkh4YQ==", + "version": "1.15.5", + "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.5.tgz", + "integrity": "sha512-PDRk21MnK70hja/YF8AHfC7yIsiQHn1rcXx7ijCFBX/k+XQJhQT/gw3xekXKJvx+5SXaMMS8oqQy09Mzvz2TuQ==", "dependencies": { - "@types/mime": "^1", + "@types/http-errors": "*", + "@types/mime": "*", "@types/node": "*" } }, "node_modules/@types/sockjs": { - "version": "0.3.33", - "resolved": "https://registry.npmjs.org/@types/sockjs/-/sockjs-0.3.33.tgz", - "integrity": "sha512-f0KEEe05NvUnat+boPTZ0dgaLZ4SfSouXUgv5noUiefG2ajgKjmETo9ZJyuqsl7dfl2aHlLJUiki6B4ZYldiiw==", + "version": "0.3.36", + "resolved": "https://registry.npmjs.org/@types/sockjs/-/sockjs-0.3.36.tgz", + "integrity": "sha512-MK9V6NzAS1+Ud7JV9lJLFqW85VbC9dq3LmwZCuBe4wBDgKC0Kj/jd8Xl+nSviU+Qc3+m7umHHyHg//2KSa0a0Q==", "dependencies": { "@types/node": "*" } @@ -3852,141 +4178,154 @@ "integrity": "sha512-PBjIUxZHOuj0R15/xuwJYjFi+KZdNFrehocChv4g5hu6aFroHue8m0lBP0POdK2nKzbw0cgV1mws8+V/JAcEkQ==" }, "node_modules/@types/ws": { - "version": "8.5.3", - "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.5.3.tgz", - "integrity": "sha512-6YOoWjruKj1uLf3INHH7D3qTXwFfEsg1kf3c0uDdSBJwfa/llkwIjrAGV7j7mVgGNbzTQ3HiHKKDXl6bJPD97w==", + "version": "8.5.9", + "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.5.9.tgz", + "integrity": "sha512-jbdrY0a8lxfdTp/+r7Z4CkycbOFN8WX+IOchLJr3juT/xzbJ8URyTVSJ/hvNdadTgM1mnedb47n+Y31GsFnQlg==", "dependencies": { "@types/node": "*" } }, + "node_modules/@types/yargs": { + "version": "17.0.31", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.31.tgz", + "integrity": "sha512-bocYSx4DI8TmdlvxqGpVNXOgCNR1Jj0gNPhhAY+iz1rgKDAaYrAYdFYnhDV1IFuiuVc9HkOwyDcFxaTElF3/wg==", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@types/yargs-parser": { + "version": "21.0.3", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz", + "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==" + }, "node_modules/@webassemblyjs/ast": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.11.1.tgz", - "integrity": "sha512-ukBh14qFLjxTQNTXocdyksN5QdM28S1CxHt2rdskFyL+xFV7VremuBLVbmCePj+URalXBENx/9Lm7lnhihtCSw==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz", + "integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==", "dependencies": { - "@webassemblyjs/helper-numbers": "1.11.1", - "@webassemblyjs/helper-wasm-bytecode": "1.11.1" + "@webassemblyjs/helper-numbers": "1.11.6", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6" } }, "node_modules/@webassemblyjs/floating-point-hex-parser": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.1.tgz", - "integrity": "sha512-iGRfyc5Bq+NnNuX8b5hwBrRjzf0ocrJPI6GWFodBFzmFnyvrQ83SHKhmilCU/8Jv67i4GJZBMhEzltxzcNagtQ==" + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz", + "integrity": "sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==" }, "node_modules/@webassemblyjs/helper-api-error": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.1.tgz", - "integrity": "sha512-RlhS8CBCXfRUR/cwo2ho9bkheSXG0+NwooXcc3PAILALf2QLdFyj7KGsKRbVc95hZnhnERon4kW/D3SZpp6Tcg==" + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz", + "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==" }, "node_modules/@webassemblyjs/helper-buffer": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.1.tgz", - "integrity": "sha512-gwikF65aDNeeXa8JxXa2BAk+REjSyhrNC9ZwdT0f8jc4dQQeDQ7G4m0f2QCLPJiMTTO6wfDmRmj/pW0PsUvIcA==" + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz", + "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw==" }, "node_modules/@webassemblyjs/helper-numbers": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.1.tgz", - "integrity": "sha512-vDkbxiB8zfnPdNK9Rajcey5C0w+QJugEglN0of+kmO8l7lDb77AnlKYQF7aarZuCrv+l0UvqL+68gSDr3k9LPQ==", + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz", + "integrity": "sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==", "dependencies": { - "@webassemblyjs/floating-point-hex-parser": "1.11.1", - "@webassemblyjs/helper-api-error": "1.11.1", + "@webassemblyjs/floating-point-hex-parser": "1.11.6", + "@webassemblyjs/helper-api-error": "1.11.6", "@xtuc/long": "4.2.2" } }, "node_modules/@webassemblyjs/helper-wasm-bytecode": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.1.tgz", - "integrity": "sha512-PvpoOGiJwXeTrSf/qfudJhwlvDQxFgelbMqtq52WWiXC6Xgg1IREdngmPN3bs4RoO83PnL/nFrxucXj1+BX62Q==" + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz", + "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==" }, "node_modules/@webassemblyjs/helper-wasm-section": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.1.tgz", - "integrity": "sha512-10P9No29rYX1j7F3EVPX3JvGPQPae+AomuSTPiF9eBQeChHI6iqjMIwR9JmOJXwpnn/oVGDk7I5IlskuMwU/pg==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz", + "integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==", "dependencies": { - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/helper-buffer": "1.11.1", - "@webassemblyjs/helper-wasm-bytecode": "1.11.1", - "@webassemblyjs/wasm-gen": "1.11.1" + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/wasm-gen": "1.12.1" } }, "node_modules/@webassemblyjs/ieee754": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.1.tgz", - "integrity": "sha512-hJ87QIPtAMKbFq6CGTkZYJivEwZDbQUgYd3qKSadTNOhVY7p+gfP6Sr0lLRVTaG1JjFj+r3YchoqRYxNH3M0GQ==", + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz", + "integrity": "sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==", "dependencies": { "@xtuc/ieee754": "^1.2.0" } }, "node_modules/@webassemblyjs/leb128": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.1.tgz", - "integrity": "sha512-BJ2P0hNZ0u+Th1YZXJpzW6miwqQUGcIHT1G/sf72gLVD9DZ5AdYTqPNbHZh6K1M5VmKvFXwGSWZADz+qBWxeRw==", + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.6.tgz", + "integrity": "sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==", "dependencies": { "@xtuc/long": "4.2.2" } }, "node_modules/@webassemblyjs/utf8": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.1.tgz", - "integrity": "sha512-9kqcxAEdMhiwQkHpkNiorZzqpGrodQQ2IGrHHxCy+Ozng0ofyMA0lTqiLkVs1uzTRejX+/O0EOT7KxqVPuXosQ==" + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.6.tgz", + "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==" }, "node_modules/@webassemblyjs/wasm-edit": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.1.tgz", - "integrity": "sha512-g+RsupUC1aTHfR8CDgnsVRVZFJqdkFHpsHMfJuWQzWU3tvnLC07UqHICfP+4XyL2tnr1amvl1Sdp06TnYCmVkA==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz", + "integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==", "dependencies": { - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/helper-buffer": "1.11.1", - "@webassemblyjs/helper-wasm-bytecode": "1.11.1", - "@webassemblyjs/helper-wasm-section": "1.11.1", - "@webassemblyjs/wasm-gen": "1.11.1", - "@webassemblyjs/wasm-opt": "1.11.1", - "@webassemblyjs/wasm-parser": "1.11.1", - "@webassemblyjs/wast-printer": "1.11.1" + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/helper-wasm-section": "1.12.1", + "@webassemblyjs/wasm-gen": "1.12.1", + "@webassemblyjs/wasm-opt": "1.12.1", + "@webassemblyjs/wasm-parser": "1.12.1", + "@webassemblyjs/wast-printer": "1.12.1" } }, "node_modules/@webassemblyjs/wasm-gen": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.1.tgz", - "integrity": "sha512-F7QqKXwwNlMmsulj6+O7r4mmtAlCWfO/0HdgOxSklZfQcDu0TpLiD1mRt/zF25Bk59FIjEuGAIyn5ei4yMfLhA==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz", + "integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==", "dependencies": { - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/helper-wasm-bytecode": "1.11.1", - "@webassemblyjs/ieee754": "1.11.1", - "@webassemblyjs/leb128": "1.11.1", - "@webassemblyjs/utf8": "1.11.1" + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/ieee754": "1.11.6", + "@webassemblyjs/leb128": "1.11.6", + "@webassemblyjs/utf8": "1.11.6" } }, "node_modules/@webassemblyjs/wasm-opt": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.1.tgz", - "integrity": "sha512-VqnkNqnZlU5EB64pp1l7hdm3hmQw7Vgqa0KF/KCNO9sIpI6Fk6brDEiX+iCOYrvMuBWDws0NkTOxYEb85XQHHw==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz", + "integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==", "dependencies": { - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/helper-buffer": "1.11.1", - "@webassemblyjs/wasm-gen": "1.11.1", - "@webassemblyjs/wasm-parser": "1.11.1" + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/wasm-gen": "1.12.1", + "@webassemblyjs/wasm-parser": "1.12.1" } }, "node_modules/@webassemblyjs/wasm-parser": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.1.tgz", - "integrity": "sha512-rrBujw+dJu32gYB7/Lup6UhdkPx9S9SnobZzRVL7VcBH9Bt9bCBLEuX/YXOOtBsOZ4NQrRykKhffRWHvigQvOA==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz", + "integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==", "dependencies": { - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/helper-api-error": "1.11.1", - "@webassemblyjs/helper-wasm-bytecode": "1.11.1", - "@webassemblyjs/ieee754": "1.11.1", - "@webassemblyjs/leb128": "1.11.1", - "@webassemblyjs/utf8": "1.11.1" + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-api-error": "1.11.6", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/ieee754": "1.11.6", + "@webassemblyjs/leb128": "1.11.6", + "@webassemblyjs/utf8": "1.11.6" } }, "node_modules/@webassemblyjs/wast-printer": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.11.1.tgz", - "integrity": "sha512-IQboUWM4eKzWW+N/jij2sRatKMh99QEelo3Eb2q0qXkvPRISAj8Qxtmw5itwqK+TTkBuUIE45AxYPToqPtL5gg==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz", + "integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==", "dependencies": { - "@webassemblyjs/ast": "1.11.1", + "@webassemblyjs/ast": "1.12.1", "@xtuc/long": "4.2.2" } }, @@ -4070,9 +4409,9 @@ } }, "node_modules/acorn-walk": { - "version": "8.2.0", - "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz", - "integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==", + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.0.tgz", + "integrity": "sha512-FS7hV565M5l1R08MXqo8odwMTB02C2UqzB17RVgu9EyuYFBqJZ3/ZY97sQD5FewVu1UyDFc1yztUDrAwT0EypA==", "engines": { "node": ">=0.4.0" } @@ -4157,30 +4496,31 @@ } }, "node_modules/algoliasearch": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-4.14.0.tgz", - "integrity": "sha512-r1rt5UQnrmqwjloi4tZzggUC7oWjNR/gfk+fjx0x4oP2UeDW5c8/XCovVFs9nwJ4n2xNKlxELyMAedcuLrBdng==", - "dependencies": { - "@algolia/cache-browser-local-storage": "4.14.0", - "@algolia/cache-common": "4.14.0", - "@algolia/cache-in-memory": "4.14.0", - "@algolia/client-account": "4.14.0", - "@algolia/client-analytics": "4.14.0", - "@algolia/client-common": "4.14.0", - "@algolia/client-personalization": "4.14.0", - "@algolia/client-search": "4.14.0", - "@algolia/logger-common": "4.14.0", - "@algolia/logger-console": "4.14.0", - "@algolia/requester-browser-xhr": "4.14.0", - "@algolia/requester-common": "4.14.0", - "@algolia/requester-node-http": "4.14.0", - "@algolia/transporter": "4.14.0" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-4.23.3.tgz", + "integrity": "sha512-Le/3YgNvjW9zxIQMRhUHuhiUjAlKY/zsdZpfq4dlLqg6mEm0nL6yk+7f2hDOtLpxsgE4jSzDmvHL7nXdBp5feg==", + "dependencies": { + "@algolia/cache-browser-local-storage": "4.23.3", + "@algolia/cache-common": "4.23.3", + "@algolia/cache-in-memory": "4.23.3", + "@algolia/client-account": "4.23.3", + "@algolia/client-analytics": "4.23.3", + "@algolia/client-common": "4.23.3", + "@algolia/client-personalization": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/logger-console": "4.23.3", + "@algolia/recommend": "4.23.3", + "@algolia/requester-browser-xhr": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/requester-node-http": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/algoliasearch-helper": { - "version": "3.10.0", - "resolved": "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.10.0.tgz", - "integrity": "sha512-4E4od8qWWDMVvQ3jaRX6Oks/k35ywD011wAA4LbYMMjOtaZV6VWaTjRr4iN2bdaXP2o1BP7SLFMBf3wvnHmd8Q==", + "version": "3.17.0", + "resolved": "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.17.0.tgz", + "integrity": "sha512-R5422OiQjvjlK3VdpNQ/Qk7KsTIGeM5ACm8civGifOVWdRRV/3SgXuKmeNxe94Dz6fwj/IgpVmXbHutU4mHubg==", "dependencies": { "@algolia/events": "^4.0.1" }, @@ -4296,9 +4636,9 @@ } }, "node_modules/autoprefixer": { - "version": "10.4.7", - "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.7.tgz", - "integrity": "sha512-ypHju4Y2Oav95SipEcCcI5J7CGPuvz8oat7sUtYj3ClK44bldfvtvcxK6IEK++7rqB7YchDGzweZIBG+SD0ZAA==", + "version": "10.4.19", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.19.tgz", + "integrity": "sha512-BaENR2+zBZ8xXhM4pUaKUxlVdxZ0EZhjvbopwnXmxRUfqDmwSpC2lAi/QXvx7NRdPCo1WKEcEF6mV64si1z4Ew==", "funding": [ { "type": "opencollective", @@ -4307,12 +4647,16 @@ { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/autoprefixer" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" } ], "dependencies": { - "browserslist": "^4.20.3", - "caniuse-lite": "^1.0.30001335", - "fraction.js": "^4.2.0", + "browserslist": "^4.23.0", + "caniuse-lite": "^1.0.30001599", + "fraction.js": "^4.3.7", "normalize-range": "^0.1.2", "picocolors": "^1.0.0", "postcss-value-parser": "^4.2.0" @@ -4336,9 +4680,9 @@ } }, "node_modules/babel-loader": { - "version": "8.2.5", - "resolved": "https://registry.npmjs.org/babel-loader/-/babel-loader-8.2.5.tgz", - "integrity": "sha512-OSiFfH89LrEMiWd4pLNqGz4CwJDtbs2ZVc+iGu2HrkRfPxId9F2anQj38IxWpmRfsUY0aBZYi1EFcd3mhtRMLQ==", + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/babel-loader/-/babel-loader-8.3.0.tgz", + "integrity": "sha512-H8SvsMF+m9t15HNLMipppzkC+Y2Yq+v3SonZyU70RBL/h1gxPkH08Ot8pEE9Z4Kd+czyWJClmFS8qzIP9OZ04Q==", "dependencies": { "find-cache-dir": "^3.3.1", "loader-utils": "^2.0.0", @@ -4353,6 +4697,23 @@ "webpack": ">=2" } }, + "node_modules/babel-loader/node_modules/schema-utils": { + "version": "2.7.1", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.1.tgz", + "integrity": "sha512-SHiNtMOUGWBQJwzISiVYKu82GiV4QYGePp3odlY1tuKO7gPtphAT5R/py0fA6xtbgLL/RvtJZnU9b8s0F1q0Xg==", + "dependencies": { + "@types/json-schema": "^7.0.5", + "ajv": "^6.12.4", + "ajv-keywords": "^3.5.2" + }, + "engines": { + "node": ">= 8.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, "node_modules/babel-plugin-apply-mdx-type-prop": { "version": "1.6.22", "resolved": "https://registry.npmjs.org/babel-plugin-apply-mdx-type-prop/-/babel-plugin-apply-mdx-type-prop-1.6.22.tgz", @@ -4400,47 +4761,47 @@ "integrity": "sha512-O4KCvQA6lLiMU9l2eawBPMf1xPP8xPfB3iEQw150hOVTqj/rfXz0ThTb4HEzqQfs2Bmo5Ay8BzxfzVtBrr9dVg==" }, "node_modules/babel-plugin-polyfill-corejs2": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.3.1.tgz", - "integrity": "sha512-v7/T6EQcNfVLfcN2X8Lulb7DjprieyLWJK/zOWH5DUYcAgex9sP3h25Q+DLsX9TloXe3y1O8l2q2Jv9q8UVB9w==", + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.6.tgz", + "integrity": "sha512-jhHiWVZIlnPbEUKSSNb9YoWcQGdlTLq7z1GHL4AjFxaoOUMuuEVJ+Y4pAaQUGOGk93YsVCKPbqbfw3m0SM6H8Q==", "dependencies": { - "@babel/compat-data": "^7.13.11", - "@babel/helper-define-polyfill-provider": "^0.3.1", - "semver": "^6.1.1" + "@babel/compat-data": "^7.22.6", + "@babel/helper-define-polyfill-provider": "^0.4.3", + "semver": "^6.3.1" }, "peerDependencies": { - "@babel/core": "^7.0.0-0" + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" } }, "node_modules/babel-plugin-polyfill-corejs2/node_modules/semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "bin": { "semver": "bin/semver.js" } }, "node_modules/babel-plugin-polyfill-corejs3": { - "version": "0.5.2", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.5.2.tgz", - "integrity": "sha512-G3uJih0XWiID451fpeFaYGVuxHEjzKTHtc9uGFEjR6hHrvNzeS/PX+LLLcetJcytsB5m4j+K3o/EpXJNb/5IEQ==", + "version": "0.8.6", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.8.6.tgz", + "integrity": "sha512-leDIc4l4tUgU7str5BWLS2h8q2N4Nf6lGZP6UrNDxdtfF2g69eJ5L0H7S8A5Ln/arfFAfHor5InAdZuIOwZdgQ==", "dependencies": { - "@babel/helper-define-polyfill-provider": "^0.3.1", - "core-js-compat": "^3.21.0" + "@babel/helper-define-polyfill-provider": "^0.4.3", + "core-js-compat": "^3.33.1" }, "peerDependencies": { - "@babel/core": "^7.0.0-0" + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" } }, "node_modules/babel-plugin-polyfill-regenerator": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.3.1.tgz", - "integrity": "sha512-Y2B06tvgHYt1x0yz17jGkGeeMr5FeKUu+ASJ+N6nB5lQ8Dapfg42i0OVrf8PNGJ3zKL4A23snMi1IRwrqqND7A==", + "version": "0.5.3", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.5.3.tgz", + "integrity": "sha512-8sHeDOmXC8csczMrYEOf0UTNa4yE2SxV5JGeT/LP1n0OYVDUUFPxG9vdk2AlDlIit4t+Kf0xCtpgXPBwnn/9pw==", "dependencies": { - "@babel/helper-define-polyfill-provider": "^0.3.1" + "@babel/helper-define-polyfill-provider": "^0.4.3" }, "peerDependencies": { - "@babel/core": "^7.0.0-0" + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" } }, "node_modules/bail": { @@ -4484,20 +4845,20 @@ } }, "node_modules/body-parser": { - "version": "1.20.0", - "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.0.tgz", - "integrity": "sha512-DfJ+q6EPcGKZD1QWUjSpqp+Q7bDQTsQIF4zfUAtZ6qk+H/3/QRhg9CEp39ss+/T2vw0+HaidC0ecJj/DRLIaKg==", + "version": "1.20.3", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz", + "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==", "dependencies": { "bytes": "3.1.2", - "content-type": "~1.0.4", + "content-type": "~1.0.5", "debug": "2.6.9", "depd": "2.0.0", "destroy": "1.2.0", "http-errors": "2.0.0", "iconv-lite": "0.4.24", "on-finished": "2.4.1", - "qs": "6.10.3", - "raw-body": "2.5.1", + "qs": "6.13.0", + "raw-body": "2.5.2", "type-is": "~1.6.18", "unpipe": "1.0.0" }, @@ -4528,9 +4889,9 @@ "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" }, "node_modules/bonjour-service": { - "version": "1.0.13", - "resolved": "https://registry.npmjs.org/bonjour-service/-/bonjour-service-1.0.13.tgz", - "integrity": "sha512-LWKRU/7EqDUC9CTAQtuZl5HzBALoCYwtLhffW3et7vZMwv3bWLpJf8bRYlMD5OCcDpTfnPgNCV4yo9ZIaJGMiA==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/bonjour-service/-/bonjour-service-1.1.1.tgz", + "integrity": "sha512-Z/5lQRMOG9k7W+FkeGTNjh7htqn/2LMnfOvBZ8pynNZCM9MwkQkI3zeI4oz09uWdcgmgHugVvBqxGg4VQJ5PCg==", "dependencies": { "array-flatten": "^2.1.2", "dns-equal": "^1.0.0", @@ -4574,20 +4935,20 @@ } }, "node_modules/braces": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", - "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", "dependencies": { - "fill-range": "^7.0.1" + "fill-range": "^7.1.1" }, "engines": { "node": ">=8" } }, "node_modules/browserslist": { - "version": "4.21.2", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.2.tgz", - "integrity": "sha512-MonuOgAtUB46uP5CezYbRaYKBNt2LxP0yX+Pmj4LkcDFGkn9Cbpi83d9sCjwQDErXsIJSzY5oKGDbgOlF/LPAA==", + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.0.tgz", + "integrity": "sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==", "funding": [ { "type": "opencollective", @@ -4596,13 +4957,17 @@ { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/browserslist" - } + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } ], "dependencies": { - "caniuse-lite": "^1.0.30001366", - "electron-to-chromium": "^1.4.188", - "node-releases": "^2.0.6", - "update-browserslist-db": "^1.0.4" + "caniuse-lite": "^1.0.30001587", + "electron-to-chromium": "^1.4.668", + "node-releases": "^2.0.14", + "update-browserslist-db": "^1.0.13" }, "bin": { "browserslist": "cli.js" @@ -4715,11 +5080,6 @@ "node": ">=4" } }, - "node_modules/buble/node_modules/regjsgen": { - "version": "0.5.2", - "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.2.tgz", - "integrity": "sha512-OFFT3MfrH90xIW8OOSyUrk6QHD5E9JOTeGodiJeBS3J6IwlgzJMNE/1bZklWz5oTg+9dCMyEetclvCVXOPoN3A==" - }, "node_modules/buble/node_modules/regjsparser": { "version": "0.7.0", "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.7.0.tgz", @@ -4803,12 +5163,18 @@ } }, "node_modules/call-bind": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", - "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz", + "integrity": "sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==", "dependencies": { - "function-bind": "^1.1.1", - "get-intrinsic": "^1.0.2" + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "set-function-length": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -4862,9 +5228,9 @@ } }, "node_modules/caniuse-lite": { - "version": "1.0.30001367", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001367.tgz", - "integrity": "sha512-XDgbeOHfifWV3GEES2B8rtsrADx4Jf+juKX2SICJcaUhjYBO3bR96kvEIHa15VU6ohtOhBZuPGGYGbXMRn0NCw==", + "version": "1.0.30001611", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001611.tgz", + "integrity": "sha512-19NuN1/3PjA3QI8Eki55N8my4LzfkMCRLgCVfrl/slbSAchQfV0+GwjPrK3rq37As4UCLlM/DHajbKkAqbv92Q==", "funding": [ { "type": "opencollective", @@ -4873,6 +5239,10 @@ { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" } ] }, @@ -4969,6 +5339,119 @@ "url": "https://github.com/sponsors/fb55" } }, + "node_modules/cheerio-select/node_modules/css-select": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz", + "integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==", + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^6.1.0", + "domhandler": "^5.0.2", + "domutils": "^3.0.1", + "nth-check": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/cheerio-select/node_modules/dom-serializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", + "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "entities": "^4.2.0" + }, + "funding": { + "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" + } + }, + "node_modules/cheerio-select/node_modules/domhandler": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "dependencies": { + "domelementtype": "^2.3.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "node_modules/cheerio-select/node_modules/domutils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.1.0.tgz", + "integrity": "sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==", + "dependencies": { + "dom-serializer": "^2.0.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, + "node_modules/cheerio/node_modules/dom-serializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", + "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "entities": "^4.2.0" + }, + "funding": { + "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" + } + }, + "node_modules/cheerio/node_modules/domhandler": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "dependencies": { + "domelementtype": "^2.3.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "node_modules/cheerio/node_modules/domutils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.1.0.tgz", + "integrity": "sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==", + "dependencies": { + "dom-serializer": "^2.0.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, + "node_modules/cheerio/node_modules/htmlparser2": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz", + "integrity": "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==", + "funding": [ + "https://github.com/fb55/htmlparser2?sponsor=1", + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1", + "entities": "^4.4.0" + } + }, "node_modules/chokidar": { "version": "3.5.3", "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", @@ -5004,14 +5487,23 @@ } }, "node_modules/ci-info": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz", - "integrity": "sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==" + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz", + "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/sibiraj-s" + } + ], + "engines": { + "node": ">=8" + } }, "node_modules/clean-css": { - "version": "5.3.1", - "resolved": "https://registry.npmjs.org/clean-css/-/clean-css-5.3.1.tgz", - "integrity": "sha512-lCr8OHhiWCTw4v8POJovCoh4T7I9U11yVsPjMWWnnMmp9ZowCxyad1Pathle/9HjaDp+fdQKjO9fQydE6RHTZg==", + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/clean-css/-/clean-css-5.3.2.tgz", + "integrity": "sha512-JVJbM+f3d3Q704rF4bqQ5UUyTtuJ0JRKNbTKVEeujCCBoMdkEi+V+e8oktO9qGQNSvHrFTM6JZRXrUvGR1czww==", "dependencies": { "source-map": "~0.6.0" }, @@ -5039,9 +5531,9 @@ } }, "node_modules/cli-table3": { - "version": "0.6.2", - "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.2.tgz", - "integrity": "sha512-QyavHCaIC80cMivimWu4aWHilIpiDpfm3hGmqAmXVL1UsnbLuBSMd21hTX6VY4ZSDSM73ESLeF8TOYId3rBTbw==", + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.3.tgz", + "integrity": "sha512-w5Jac5SykAeZJKntOxJCrm63Eg5/4dhMWIcuTbo9rpE+brgaSZo0RuNJZeOyMgsUdhDeojvgyQLmjI+K50ZGyg==", "dependencies": { "string-width": "^4.2.0" }, @@ -5133,14 +5625,14 @@ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" }, "node_modules/colord": { - "version": "2.9.2", - "resolved": "https://registry.npmjs.org/colord/-/colord-2.9.2.tgz", - "integrity": "sha512-Uqbg+J445nc1TKn4FoDPS6ZZqAvEDnwrH42yo8B40JSOgSLxMZ/gt3h4nmCtPLQeXhjJJkqBx7SCY35WnIixaQ==" + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/colord/-/colord-2.9.3.tgz", + "integrity": "sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==" }, "node_modules/colorette": { - "version": "2.0.19", - "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.19.tgz", - "integrity": "sha512-3tlv/dIP7FWvj3BsbHrGLJ6l/oKh1O3TcgBqMn+yyCagOxc23fyzDS6HypQbgxWbkpDnf52p1LuR4eWDQ/K9WQ==" + "version": "2.0.20", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz", + "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==" }, "node_modules/combine-promises": { "version": "1.1.0", @@ -5274,25 +5766,22 @@ } }, "node_modules/content-type": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz", - "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==", + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", "engines": { "node": ">= 0.6" } }, "node_modules/convert-source-map": { - "version": "1.8.0", - "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.8.0.tgz", - "integrity": "sha512-+OQdjP49zViI/6i7nIJpA8rAl4sV/JdPfU9nZs3VqOwGIgizICvuN2ru6fMd+4llL0tar18UYJXfZ/TWtmhUjA==", - "dependencies": { - "safe-buffer": "~5.1.1" - } + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==" }, "node_modules/cookie": { - "version": "0.5.0", - "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz", - "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==", + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz", + "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==", "engines": { "node": ">= 0.6" } @@ -5303,9 +5792,9 @@ "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==" }, "node_modules/copy-text-to-clipboard": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/copy-text-to-clipboard/-/copy-text-to-clipboard-3.0.1.tgz", - "integrity": "sha512-rvVsHrpFcL4F2P8ihsoLdFHmd404+CMg71S756oRSeQgqk51U3kicGdnvfkrxva0xXH92SjGS62B0XIJsbh+9Q==", + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/copy-text-to-clipboard/-/copy-text-to-clipboard-3.2.0.tgz", + "integrity": "sha512-RnJFp1XR/LOBDckxTib5Qjr/PMfkatD0MUCQgdpqS8MdKiNUzBjAQBEN6oUy+jW7LI93BBG3DtMB2KOOKpGs2Q==", "engines": { "node": ">=12" }, @@ -5336,32 +5825,6 @@ "webpack": "^5.1.0" } }, - "node_modules/copy-webpack-plugin/node_modules/ajv": { - "version": "8.11.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz", - "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==", - "dependencies": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/epoberezkin" - } - }, - "node_modules/copy-webpack-plugin/node_modules/ajv-keywords": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", - "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", - "dependencies": { - "fast-deep-equal": "^3.1.3" - }, - "peerDependencies": { - "ajv": "^8.8.2" - } - }, "node_modules/copy-webpack-plugin/node_modules/glob-parent": { "version": "6.0.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", @@ -5391,29 +5854,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/copy-webpack-plugin/node_modules/json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" - }, - "node_modules/copy-webpack-plugin/node_modules/schema-utils": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", - "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", - "dependencies": { - "@types/json-schema": "^7.0.9", - "ajv": "^8.8.0", - "ajv-formats": "^2.1.1", - "ajv-keywords": "^5.0.0" - }, - "engines": { - "node": ">= 12.13.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/webpack" - } - }, "node_modules/copy-webpack-plugin/node_modules/slash": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz", @@ -5426,9 +5866,9 @@ } }, "node_modules/core-js": { - "version": "3.23.5", - "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.23.5.tgz", - "integrity": "sha512-7Vh11tujtAZy82da4duVreQysIoO2EvVrur7y6IzZkH1IHPSekuDi8Vuw1+YKjkbfWLRD7Nc9ICQ/sIUDutcyg==", + "version": "3.33.2", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.33.2.tgz", + "integrity": "sha512-XeBzWI6QL3nJQiHmdzbAOiMYqjrb7hwU7A39Qhvd/POSa/t9E1AeZyEZx3fNvp/vtM8zXwhoL0FsiS0hD0pruQ==", "hasInstallScript": true, "funding": { "type": "opencollective", @@ -5436,30 +5876,21 @@ } }, "node_modules/core-js-compat": { - "version": "3.23.5", - "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.23.5.tgz", - "integrity": "sha512-fHYozIFIxd+91IIbXJgWd/igXIc8Mf9is0fusswjnGIWVG96y2cwyUdlCkGOw6rMLHKAxg7xtCIVaHsyOUnJIg==", + "version": "3.33.2", + "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.33.2.tgz", + "integrity": "sha512-axfo+wxFVxnqf8RvxTzoAlzW4gRoacrHeoFlc9n0x50+7BEyZL/Rt3hicaED1/CEd7I6tPCPVUYcJwCMO5XUYw==", "dependencies": { - "browserslist": "^4.21.2", - "semver": "7.0.0" + "browserslist": "^4.22.1" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/core-js" } }, - "node_modules/core-js-compat/node_modules/semver": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.0.0.tgz", - "integrity": "sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==", - "bin": { - "semver": "bin/semver.js" - } - }, "node_modules/core-js-pure": { - "version": "3.23.5", - "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.23.5.tgz", - "integrity": "sha512-8t78LdpKSuCq4pJYCYk8hl7XEkAX+BP16yRIwL3AanTksxuEf7CM83vRyctmiEL8NDZ3jpUcv56fk9/zG3aIuw==", + "version": "3.33.2", + "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.33.2.tgz", + "integrity": "sha512-a8zeCdyVk7uF2elKIGz67AjcXOxjRbwOLz8SbklEso1V+2DoW4OkAMZN9S9GBgvZIaqQi/OemFX4OiSoQEmg1Q==", "hasInstallScript": true, "funding": { "type": "opencollective", @@ -5472,9 +5903,9 @@ "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==" }, "node_modules/cosmiconfig": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.0.1.tgz", - "integrity": "sha512-a1YWNUV2HwGimB7dU2s1wUMurNKjpx60HxBB6xUM8Re+2s1g1IIfJvFR0/iCF+XHdE0GMTKTuLR32UQff4TEyQ==", + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.1.0.tgz", + "integrity": "sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==", "dependencies": { "@types/parse-json": "^4.0.0", "import-fresh": "^3.2.1", @@ -5487,17 +5918,17 @@ } }, "node_modules/cross-fetch": { - "version": "3.1.5", - "resolved": "https://registry.npmjs.org/cross-fetch/-/cross-fetch-3.1.5.tgz", - "integrity": "sha512-lvb1SBsI0Z7GDwmuid+mU3kWVBwTVUbe7S0H52yaaAdQOXq2YktTCZdlAcNKFzE6QtRz0snpw9bNiPeOIkkQvw==", + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/cross-fetch/-/cross-fetch-3.1.8.tgz", + "integrity": "sha512-cvA+JwZoU0Xq+h6WkMvAUqPEYy92Obet6UdKLfW60qn99ftItKjB5T+BkyWOFWe2pUyfQ+IJHmpOTznqk1M6Kg==", "dependencies": { - "node-fetch": "2.6.7" + "node-fetch": "^2.6.12" } }, "node_modules/cross-spawn": { - "version": "7.0.3", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", - "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", @@ -5516,9 +5947,9 @@ } }, "node_modules/css-declaration-sorter": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-6.3.0.tgz", - "integrity": "sha512-OGT677UGHJTAVMRhPO+HJ4oKln3wkBTwtDFH0ojbqm+MJm6xuDMHp2nkhh/ThaBqq20IbraBQSWKfSLNHQO9Og==", + "version": "6.4.1", + "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-6.4.1.tgz", + "integrity": "sha512-rtdthzxKuyq6IzqX6jEcIzQF/YqccluefyCYheovBOLhFT/drQA9zj/UbRAa9J7C0o6EG6u3E6g+vKkay7/k3g==", "engines": { "node": "^10 || ^12 || >=14" }, @@ -5527,18 +5958,18 @@ } }, "node_modules/css-loader": { - "version": "6.7.1", - "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-6.7.1.tgz", - "integrity": "sha512-yB5CNFa14MbPJcomwNh3wLThtkZgcNyI2bNMRt8iE5Z8Vwl7f8vQXFAzn2HDOJvtDq2NTZBUGMSUNNyrv3/+cw==", + "version": "6.8.1", + "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-6.8.1.tgz", + "integrity": "sha512-xDAXtEVGlD0gJ07iclwWVkLoZOpEvAWaSyf6W18S2pOC//K8+qUDIx8IIT3D+HjnmkJPQeesOPv5aiUaJsCM2g==", "dependencies": { "icss-utils": "^5.1.0", - "postcss": "^8.4.7", + "postcss": "^8.4.21", "postcss-modules-extract-imports": "^3.0.0", - "postcss-modules-local-by-default": "^4.0.0", + "postcss-modules-local-by-default": "^4.0.3", "postcss-modules-scope": "^3.0.0", "postcss-modules-values": "^4.0.0", "postcss-value-parser": "^4.2.0", - "semver": "^7.3.5" + "semver": "^7.3.8" }, "engines": { "node": ">= 12.13.0" @@ -5552,13 +5983,13 @@ } }, "node_modules/css-minimizer-webpack-plugin": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-4.0.0.tgz", - "integrity": "sha512-7ZXXRzRHvofv3Uac5Y+RkWRNo0ZMlcg8e9/OtrqUYmwDWJo+qs67GvdeFrXLsFb7czKNwjQhPkM0avlIYl+1nA==", + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-4.2.2.tgz", + "integrity": "sha512-s3Of/4jKfw1Hj9CxEO1E5oXhQAxlayuHO2y/ML+C6I9sQ7FdzfEV6QgMLN3vI+qFsjJGIAFLKtQK7t8BOXAIyA==", "dependencies": { "cssnano": "^5.1.8", - "jest-worker": "^27.5.1", - "postcss": "^8.4.13", + "jest-worker": "^29.1.2", + "postcss": "^8.4.17", "schema-utils": "^4.0.0", "serialize-javascript": "^6.0.0", "source-map": "^0.6.1" @@ -5577,6 +6008,9 @@ "@parcel/css": { "optional": true }, + "@swc/css": { + "optional": true + }, "clean-css": { "optional": true }, @@ -5585,67 +6019,49 @@ }, "esbuild": { "optional": true + }, + "lightningcss": { + "optional": true } } }, - "node_modules/css-minimizer-webpack-plugin/node_modules/ajv": { - "version": "8.11.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz", - "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==", - "dependencies": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/epoberezkin" - } - }, - "node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", - "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "node_modules/css-minimizer-webpack-plugin/node_modules/jest-worker": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-29.7.0.tgz", + "integrity": "sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==", "dependencies": { - "fast-deep-equal": "^3.1.3" + "@types/node": "*", + "jest-util": "^29.7.0", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" }, - "peerDependencies": { - "ajv": "^8.8.2" + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" } }, - "node_modules/css-minimizer-webpack-plugin/node_modules/json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" - }, - "node_modules/css-minimizer-webpack-plugin/node_modules/schema-utils": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", - "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", + "node_modules/css-minimizer-webpack-plugin/node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", "dependencies": { - "@types/json-schema": "^7.0.9", - "ajv": "^8.8.0", - "ajv-formats": "^2.1.1", - "ajv-keywords": "^5.0.0" + "has-flag": "^4.0.0" }, "engines": { - "node": ">= 12.13.0" + "node": ">=10" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/webpack" + "url": "https://github.com/chalk/supports-color?sponsor=1" } }, "node_modules/css-select": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz", - "integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==", + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz", + "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==", "dependencies": { "boolbase": "^1.0.0", - "css-what": "^6.1.0", - "domhandler": "^5.0.2", - "domutils": "^3.0.1", + "css-what": "^6.0.1", + "domhandler": "^4.3.1", + "domutils": "^2.8.0", "nth-check": "^2.0.1" }, "funding": { @@ -5687,11 +6103,11 @@ } }, "node_modules/cssnano": { - "version": "5.1.12", - "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-5.1.12.tgz", - "integrity": "sha512-TgvArbEZu0lk/dvg2ja+B7kYoD7BBCmn3+k58xD0qjrGHsFzXY/wKTo9M5egcUCabPol05e/PVoIu79s2JN4WQ==", + "version": "5.1.15", + "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-5.1.15.tgz", + "integrity": "sha512-j+BKgDcLDQA+eDifLx0EO4XSA56b7uut3BQFH+wbSaSTuGLuiyTa/wbRYthUXX8LC9mLg+WWKe8h+qJuwTAbHw==", "dependencies": { - "cssnano-preset-default": "^5.2.12", + "cssnano-preset-default": "^5.2.14", "lilconfig": "^2.0.3", "yaml": "^1.10.2" }, @@ -5707,12 +6123,12 @@ } }, "node_modules/cssnano-preset-advanced": { - "version": "5.3.8", - "resolved": "https://registry.npmjs.org/cssnano-preset-advanced/-/cssnano-preset-advanced-5.3.8.tgz", - "integrity": "sha512-xUlLLnEB1LjpEik+zgRNlk8Y/koBPPtONZjp7JKbXigeAmCrFvq9H0pXW5jJV45bQWAlmJ0sKy+IMr0XxLYQZg==", + "version": "5.3.10", + "resolved": "https://registry.npmjs.org/cssnano-preset-advanced/-/cssnano-preset-advanced-5.3.10.tgz", + "integrity": "sha512-fnYJyCS9jgMU+cmHO1rPSPf9axbQyD7iUhLO5Df6O4G+fKIOMps+ZbU0PdGFejFBBZ3Pftf18fn1eG7MAPUSWQ==", "dependencies": { - "autoprefixer": "^10.3.7", - "cssnano-preset-default": "^5.2.12", + "autoprefixer": "^10.4.12", + "cssnano-preset-default": "^5.2.14", "postcss-discard-unused": "^5.1.0", "postcss-merge-idents": "^5.1.1", "postcss-reduce-idents": "^5.2.0", @@ -5726,24 +6142,24 @@ } }, "node_modules/cssnano-preset-default": { - "version": "5.2.12", - "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-5.2.12.tgz", - "integrity": "sha512-OyCBTZi+PXgylz9HAA5kHyoYhfGcYdwFmyaJzWnzxuGRtnMw/kR6ilW9XzlzlRAtB6PLT/r+prYgkef7hngFew==", + "version": "5.2.14", + "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-5.2.14.tgz", + "integrity": "sha512-t0SFesj/ZV2OTylqQVOrFgEh5uanxbO6ZAdeCrNsUQ6fVuXwYTxJPNAGvGTxHbD68ldIJNec7PyYZDBrfDQ+6A==", "dependencies": { - "css-declaration-sorter": "^6.3.0", + "css-declaration-sorter": "^6.3.1", "cssnano-utils": "^3.1.0", "postcss-calc": "^8.2.3", - "postcss-colormin": "^5.3.0", - "postcss-convert-values": "^5.1.2", + "postcss-colormin": "^5.3.1", + "postcss-convert-values": "^5.1.3", "postcss-discard-comments": "^5.1.2", "postcss-discard-duplicates": "^5.1.0", "postcss-discard-empty": "^5.1.1", "postcss-discard-overridden": "^5.1.0", - "postcss-merge-longhand": "^5.1.6", - "postcss-merge-rules": "^5.1.2", + "postcss-merge-longhand": "^5.1.7", + "postcss-merge-rules": "^5.1.4", "postcss-minify-font-values": "^5.1.0", "postcss-minify-gradients": "^5.1.1", - "postcss-minify-params": "^5.1.3", + "postcss-minify-params": "^5.1.4", "postcss-minify-selectors": "^5.2.1", "postcss-normalize-charset": "^5.1.0", "postcss-normalize-display-values": "^5.1.0", @@ -5751,11 +6167,11 @@ "postcss-normalize-repeat-style": "^5.1.1", "postcss-normalize-string": "^5.1.0", "postcss-normalize-timing-functions": "^5.1.0", - "postcss-normalize-unicode": "^5.1.0", + "postcss-normalize-unicode": "^5.1.1", "postcss-normalize-url": "^5.1.0", "postcss-normalize-whitespace": "^5.1.1", "postcss-ordered-values": "^5.1.3", - "postcss-reduce-initial": "^5.1.0", + "postcss-reduce-initial": "^5.1.2", "postcss-reduce-transforms": "^5.1.0", "postcss-svgo": "^5.1.0", "postcss-unique-selectors": "^5.1.1" @@ -5794,6 +6210,11 @@ "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.0.tgz", "integrity": "sha512-uX1KG+x9h5hIJsaKR9xHUeUraxf8IODOwq9JLNPq6BwB04a/xgpq3rcx47l5BZu5zBPlgD342tdke3Hom/nJRA==" }, + "node_modules/debounce": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/debounce/-/debounce-1.2.1.tgz", + "integrity": "sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==" + }, "node_modules/debug": { "version": "4.3.4", "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", @@ -5853,6 +6274,22 @@ "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-1.1.3.tgz", "integrity": "sha512-0ISdNousHvZT2EiFlZeZAHBUvSxmKswVCEf8hW7KWgG4a8MVEu/3Vb6uWYozkjylyCxe0JBIiRB1jV45S70WVQ==" }, + "node_modules/define-data-property": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", + "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", + "dependencies": { + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/define-lazy-prop": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz", @@ -5932,19 +6369,16 @@ "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==" }, "node_modules/detect-port": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/detect-port/-/detect-port-1.3.0.tgz", - "integrity": "sha512-E+B1gzkl2gqxt1IhUzwjrxBKRqx1UzC3WLONHinn8S3T6lwV/agVCyitiFOsGJ/eYuEUBvD71MZHy3Pv1G9doQ==", + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/detect-port/-/detect-port-1.5.1.tgz", + "integrity": "sha512-aBzdj76lueB6uUst5iAs7+0H/oOjqI5D16XUWxlWMIMROhcM0rfsNVk93zTngq1dDNpoXRr++Sus7ETAExppAQ==", "dependencies": { "address": "^1.0.1", - "debug": "^2.6.0" + "debug": "4" }, "bin": { - "detect": "bin/detect-port", - "detect-port": "bin/detect-port" - }, - "engines": { - "node": ">= 4.2.1" + "detect": "bin/detect-port.js", + "detect-port": "bin/detect-port.js" } }, "node_modules/detect-port-alt": { @@ -5976,19 +6410,6 @@ "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" }, - "node_modules/detect-port/node_modules/debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", - "dependencies": { - "ms": "2.0.0" - } - }, - "node_modules/detect-port/node_modules/ms": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" - }, "node_modules/dir-glob": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", @@ -6006,9 +6427,9 @@ "integrity": "sha512-z+paD6YUQsk+AbGCEM4PrOXSss5gd66QfcVBFTKR/HpFL9jCqikS94HYwKww6fQyO7IxrIIyUu+g0Ka9tUS2Cg==" }, "node_modules/dns-packet": { - "version": "5.4.0", - "resolved": "https://registry.npmjs.org/dns-packet/-/dns-packet-5.4.0.tgz", - "integrity": "sha512-EgqGeaBB8hLiHLZtp/IbaDQTL8pZ0+IvwzSHA6d7VyMDM+B9hgddEMa9xjK5oYnw0ci0JQ6g2XCD7/f6cafU6g==", + "version": "5.6.1", + "resolved": "https://registry.npmjs.org/dns-packet/-/dns-packet-5.6.1.tgz", + "integrity": "sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==", "dependencies": { "@leichtgewicht/ip-codec": "^2.0.1" }, @@ -6017,14 +6438,14 @@ } }, "node_modules/docusaurus-plugin-sass": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/docusaurus-plugin-sass/-/docusaurus-plugin-sass-0.2.2.tgz", - "integrity": "sha512-ZZBpj3PrhGpYE2kAnkZB9NRwy/CDi4rGun1oec6PYR8YvGzqxYGtXvLgHi6FFbu8/N483klk8udqyYMh6Ted+A==", + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/docusaurus-plugin-sass/-/docusaurus-plugin-sass-0.2.5.tgz", + "integrity": "sha512-Z+D0fLFUKcFpM+bqSUmqKIU+vO+YF1xoEQh5hoFreg2eMf722+siwXDD+sqtwU8E4MvVpuvsQfaHwODNlxJAEg==", "dependencies": { "sass-loader": "^10.1.1" }, "peerDependencies": { - "@docusaurus/core": "^2.0.0-beta", + "@docusaurus/core": "^2.0.0-beta || ^3.0.0-alpha", "sass": "^1.30.0" } }, @@ -6046,25 +6467,22 @@ } }, "node_modules/dom-serializer": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", - "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz", + "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==", "dependencies": { - "domelementtype": "^2.3.0", - "domhandler": "^5.0.2", - "entities": "^4.2.0" + "domelementtype": "^2.0.1", + "domhandler": "^4.2.0", + "entities": "^2.0.0" }, "funding": { "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" } }, "node_modules/dom-serializer/node_modules/entities": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/entities/-/entities-4.3.1.tgz", - "integrity": "sha512-o4q/dYJlmyjP2zfnaWDUC6A3BQFmVTX+tZPezK7k0GLSU9QYCauscf5Y+qcEPzKL+EixVouYDgLQK5H9GrLpkg==", - "engines": { - "node": ">=0.12" - }, + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", + "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==", "funding": { "url": "https://github.com/fb55/entities?sponsor=1" } @@ -6081,11 +6499,11 @@ ] }, "node_modules/domhandler": { - "version": "5.0.3", - "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", - "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz", + "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==", "dependencies": { - "domelementtype": "^2.3.0" + "domelementtype": "^2.2.0" }, "engines": { "node": ">= 4" @@ -6095,13 +6513,13 @@ } }, "node_modules/domutils": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.0.1.tgz", - "integrity": "sha512-z08c1l761iKhDFtfXO04C7kTdPBLi41zwOZl00WS8b5eiaebNpY00HKbztwBq+e3vyqWNwWF3mP9YLUeqIrF+Q==", + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz", + "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==", "dependencies": { - "dom-serializer": "^2.0.0", - "domelementtype": "^2.3.0", - "domhandler": "^5.0.1" + "dom-serializer": "^1.0.1", + "domelementtype": "^2.2.0", + "domhandler": "^4.2.0" }, "funding": { "url": "https://github.com/fb55/domutils?sponsor=1" @@ -6156,9 +6574,9 @@ "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==" }, "node_modules/electron-to-chromium": { - "version": "1.4.192", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.192.tgz", - "integrity": "sha512-8nCXyIQY9An88NXAp+PuPy5h3/w5ZY7Iu2lag65Q0XREprcat5F8gKhoHsBUnQcFuCRnmevpR8yEBYRU3d2HDw==" + "version": "1.4.741", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.741.tgz", + "integrity": "sha512-AyTBZqDoS7/mvQK22gOQpjxbeV8iPeUBTvYlEh/1S9dKAHgQdxuF49g9rLbj0cRKtqH8PzLJzqT3nAdl+qoZTA==" }, "node_modules/emoji-regex": { "version": "9.2.2", @@ -6183,9 +6601,9 @@ } }, "node_modules/encodeurl": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", - "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", "engines": { "node": ">= 0.8" } @@ -6199,9 +6617,9 @@ } }, "node_modules/enhanced-resolve": { - "version": "5.10.0", - "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.10.0.tgz", - "integrity": "sha512-T0yTFjdpldGY8PmuXXR0PyQ1ufZpEGiHVrp7zHKB7jdR4qlmZHhONVM5AQOAWXuF/w3dnHbEQVrNptJgt7F+cQ==", + "version": "5.17.1", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.17.1.tgz", + "integrity": "sha512-LMHl3dXhTcfv8gM4kEzIUeTQ+7fpdA0l2tUf34BddXPkz2A5xJ5L/Pchd5BL6rdccM9QGvu0sWZzK1Z1t4wwyg==", "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.2.0" @@ -6211,9 +6629,9 @@ } }, "node_modules/entities": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/entities/-/entities-3.0.1.tgz", - "integrity": "sha512-WiyBqoomrwMdFG1e0kqvASYfnlb0lp8M5o5Fw2OFq1hNZxxcNk8Ik0Xm7LxzBhuidnZB/UtBqVCgUz3kBOP51Q==", + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", + "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==", "engines": { "node": ">=0.12" }, @@ -6229,10 +6647,29 @@ "is-arrayish": "^0.2.1" } }, + "node_modules/es-define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz", + "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==", + "dependencies": { + "get-intrinsic": "^1.2.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "engines": { + "node": ">= 0.4" + } + }, "node_modules/es-module-lexer": { - "version": "0.9.3", - "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-0.9.3.tgz", - "integrity": "sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ==" + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.4.1.tgz", + "integrity": "sha512-cXLGjP0c4T3flZJKQSuziYoq7MlT+rnvfZjfp7h+I7K9BNX54kP9nyWvdbwjQ4u1iWbOL4u96fgeZLToQlZC7w==" }, "node_modules/escalade": { "version": "3.1.1", @@ -6326,9 +6763,9 @@ } }, "node_modules/eta": { - "version": "1.12.3", - "resolved": "https://registry.npmjs.org/eta/-/eta-1.12.3.tgz", - "integrity": "sha512-qHixwbDLtekO/d51Yr4glcaUJCIjGVJyTzuqV4GPlgZo1YpgOKG+avQynErZIYrfM6JIJdtiG2Kox8tbb+DoGg==", + "version": "1.14.2", + "resolved": "https://registry.npmjs.org/eta/-/eta-1.14.2.tgz", + "integrity": "sha512-wZmJAV7EFUG5W8XNXSazIdichnWEhGB1OWg4tnXWPj0CPNUcFdgorGNO6N9p6WBUgoUe4P0OziJYn1+6zxP2aQ==", "engines": { "node": ">=6.0.0" }, @@ -6391,48 +6828,37 @@ "url": "https://github.com/sindresorhus/execa?sponsor=1" } }, - "node_modules/execa/node_modules/get-stream": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", - "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/express": { - "version": "4.18.1", - "resolved": "https://registry.npmjs.org/express/-/express-4.18.1.tgz", - "integrity": "sha512-zZBcOX9TfehHQhtupq57OF8lFZ3UZi08Y97dwFCkD8p9d/d2Y3M+ykKcwaMDEL+4qyUolgBDX6AblpR3fL212Q==", + "version": "4.21.1", + "resolved": "https://registry.npmjs.org/express/-/express-4.21.1.tgz", + "integrity": "sha512-YSFlK1Ee0/GC8QaO91tHcDxJiE/X4FbpAyQWkxAvG6AXCuR65YzK8ua6D9hvi/TzUfZMpc+BwuM1IPw8fmQBiQ==", "dependencies": { "accepts": "~1.3.8", "array-flatten": "1.1.1", - "body-parser": "1.20.0", + "body-parser": "1.20.3", "content-disposition": "0.5.4", "content-type": "~1.0.4", - "cookie": "0.5.0", + "cookie": "0.7.1", "cookie-signature": "1.0.6", "debug": "2.6.9", "depd": "2.0.0", - "encodeurl": "~1.0.2", + "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "etag": "~1.8.1", - "finalhandler": "1.2.0", + "finalhandler": "1.3.1", "fresh": "0.5.2", "http-errors": "2.0.0", - "merge-descriptors": "1.0.1", + "merge-descriptors": "1.0.3", "methods": "~1.1.2", "on-finished": "2.4.1", "parseurl": "~1.3.3", - "path-to-regexp": "0.1.7", + "path-to-regexp": "0.1.10", "proxy-addr": "~2.0.7", - "qs": "6.10.3", + "qs": "6.13.0", "range-parser": "~1.2.1", "safe-buffer": "5.2.1", - "send": "0.18.0", - "serve-static": "1.15.0", + "send": "0.19.0", + "serve-static": "1.16.2", "setprototypeof": "1.2.0", "statuses": "2.0.1", "type-is": "~1.6.18", @@ -6473,9 +6899,9 @@ "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" }, "node_modules/express/node_modules/path-to-regexp": { - "version": "0.1.7", - "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz", - "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==" + "version": "0.1.10", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.10.tgz", + "integrity": "sha512-7lf7qcQidTku0Gu3YDPc8DJ1q7OOucfa/BSsIwjuh56VU7katFvuM8hULfkwB3Fns/rsVF7PwPKVw1sl5KQS9w==" }, "node_modules/express/node_modules/range-parser": { "version": "1.2.1", @@ -6581,9 +7007,9 @@ } }, "node_modules/fbjs": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/fbjs/-/fbjs-3.0.4.tgz", - "integrity": "sha512-ucV0tDODnGV3JCnnkmoszb5lf4bNpzjv80K41wd4k798Etq+UYD0y0TIfalLjZoKgjive6/adkRnszwapiDgBQ==", + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/fbjs/-/fbjs-3.0.5.tgz", + "integrity": "sha512-ztsSx77JBtkuMrEypfhgc3cI0+0h+svqeie7xHbh1k/IKdcydnvadp/mUaGgjAOXQmQSxsqgaRhS3q9fy+1kxg==", "dependencies": { "cross-fetch": "^3.1.5", "fbjs-css-vars": "^1.0.0", @@ -6591,7 +7017,7 @@ "object-assign": "^4.1.0", "promise": "^7.1.1", "setimmediate": "^1.0.5", - "ua-parser-js": "^0.7.30" + "ua-parser-js": "^1.0.35" } }, "node_modules/fbjs-css-vars": { @@ -6655,9 +7081,9 @@ } }, "node_modules/fill-range": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", - "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", "dependencies": { "to-regex-range": "^5.0.1" }, @@ -6666,12 +7092,12 @@ } }, "node_modules/finalhandler": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz", - "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==", + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz", + "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==", "dependencies": { "debug": "2.6.9", - "encodeurl": "~1.0.2", + "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "on-finished": "2.4.1", "parseurl": "~1.3.3", @@ -6723,10 +7149,18 @@ "node": ">=8" } }, + "node_modules/flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "bin": { + "flat": "cli.js" + } + }, "node_modules/flux": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/flux/-/flux-4.0.3.tgz", - "integrity": "sha512-yKAbrp7JhZhj6uiT1FTuVMlIAT1J4jqEyBpFApi1kxpGZCvacMVc/t1pMQyotqHhAgvoE3bNvAykhCo2CLjnYw==", + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/flux/-/flux-4.0.4.tgz", + "integrity": "sha512-NCj3XlayA2UsapRpM7va6wU1+9rE5FIL7qoMcmxWHRzbp0yujihMBm9BBHZ1MDIk5h5o2Bl6eGiCe8rYELAmYw==", "dependencies": { "fbemitter": "^3.0.0", "fbjs": "^3.0.1" @@ -6736,9 +7170,9 @@ } }, "node_modules/follow-redirects": { - "version": "1.15.1", - "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.1.tgz", - "integrity": "sha512-yLAMQs+k0b2m7cVxpS1VKJVvoz7SS9Td1zss3XRwXj+ZDH00RJgnuLx7E44wx02kQLrdM3aOOy+FpzS7+8OizA==", + "version": "1.15.6", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.6.tgz", + "integrity": "sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==", "funding": [ { "type": "individual", @@ -6855,15 +7289,15 @@ } }, "node_modules/fraction.js": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.2.0.tgz", - "integrity": "sha512-MhLuK+2gUcnZe8ZHlaaINnQLl0xRIGRfcGk2yl8xoQAfHrSsL3rYu6FCmBdkdbhc9EPlwyGHewaRsvwRMJtAlA==", + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz", + "integrity": "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==", "engines": { "node": "*" }, "funding": { "type": "patreon", - "url": "https://www.patreon.com/infusion" + "url": "https://github.com/sponsors/rawify" } }, "node_modules/fresh": { @@ -6911,9 +7345,12 @@ } }, "node_modules/function-bind": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", - "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==" + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } }, "node_modules/gensync": { "version": "1.0.0-beta.2", @@ -6924,13 +7361,18 @@ } }, "node_modules/get-intrinsic": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.2.tgz", - "integrity": "sha512-Jfm3OyCxHh9DJyc28qGk+JmfkpO41A4XkneDSujN9MDXrm4oDKdHvndhZ2dN94+ERNfkYJWDclW6k2L/ZGHjXA==", + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz", + "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==", "dependencies": { - "function-bind": "^1.1.1", - "has": "^1.0.3", - "has-symbols": "^1.0.3" + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "hasown": "^2.0.0" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -6942,20 +7384,20 @@ "integrity": "sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==" }, "node_modules/get-stream": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz", - "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==", - "dependencies": { - "pump": "^3.0.0" - }, + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", "engines": { - "node": ">=6" + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/github-slugger": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/github-slugger/-/github-slugger-1.4.0.tgz", - "integrity": "sha512-w0dzqw/nt51xMVmlaV1+JRzN+oCa1KfcgGEWhxUG16wbdA+Xnt/yoFO8Z8x/V82ZcZ0wy6ln9QDup5avbhiDhQ==" + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/github-slugger/-/github-slugger-1.5.0.tgz", + "integrity": "sha512-wIh+gKBI9Nshz2o46B0B3f5k/W+WI9ZAv6y5Dn5WJ5SK1t0TnDimB4WE5rmTD05ZAIn8HALCZVmCsvj0w0v0lw==" }, "node_modules/glob": { "version": "7.2.3", @@ -6993,9 +7435,9 @@ "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==" }, "node_modules/global-dirs": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-3.0.0.tgz", - "integrity": "sha512-v8ho2DS5RiCjftj1nD9NmnfaOzTdud7RRnVd9kFNOjqZbISlx5DQ+OrTkywgd0dIt7oFCvKetZSHoHcP3sDdiA==", + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-3.0.1.tgz", + "integrity": "sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==", "dependencies": { "ini": "2.0.0" }, @@ -7076,6 +7518,17 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "dependencies": { + "get-intrinsic": "^1.1.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/got": { "version": "9.6.0", "resolved": "https://registry.npmjs.org/got/-/got-9.6.0.tgz", @@ -7097,10 +7550,21 @@ "node": ">=8.6" } }, + "node_modules/got/node_modules/get-stream": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz", + "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==", + "dependencies": { + "pump": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, "node_modules/graceful-fs": { - "version": "4.2.10", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", - "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==" + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==" }, "node_modules/gray-matter": { "version": "4.0.3", @@ -7175,11 +7639,22 @@ } }, "node_modules/has-property-descriptors": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", - "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", + "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", "dependencies": { - "get-intrinsic": "^1.1.1" + "es-define-property": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-proto": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz", + "integrity": "sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==", + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -7204,6 +7679,17 @@ "node": ">=8" } }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/hast-to-hyperscript": { "version": "9.0.1", "resolved": "https://registry.npmjs.org/hast-to-hyperscript/-/hast-to-hyperscript-9.0.1.tgz", @@ -7360,9 +7846,9 @@ "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==" }, "node_modules/hpack.js/node_modules/readable-stream": { - "version": "2.3.7", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz", - "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==", + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz", + "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==", "dependencies": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", @@ -7382,9 +7868,24 @@ } }, "node_modules/html-entities": { - "version": "2.3.3", - "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.3.3.tgz", - "integrity": "sha512-DV5Ln36z34NNTDgnz0EWGBLZENelNAtkiFA4kyNOG2tDI6Mz1uSWiq1wAKdyjnJwyDiDO7Fa2SO1CTxPXL8VxA==" + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.4.0.tgz", + "integrity": "sha512-igBTJcNNNhvZFRtm8uA6xMY6xYleeDwn3PeBCkDz7tHttv4F2hsDI2aPgNERWzvRcNYHNT3ymRaQzllmXj4YsQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/mdevils" + }, + { + "type": "patreon", + "url": "https://patreon.com/mdevils" + } + ] + }, + "node_modules/html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==" }, "node_modules/html-minifier-terser": { "version": "6.1.0", @@ -7415,9 +7916,9 @@ } }, "node_modules/html-tags": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/html-tags/-/html-tags-3.2.0.tgz", - "integrity": "sha512-vy7ClnArOZwCnqZgvv+ddgHgJiAFXe3Ge9ML5/mBctVJoUoYPCdxVucOywjDARn6CVoh3dRSFdPHy2sX80L0Wg==", + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/html-tags/-/html-tags-3.3.1.tgz", + "integrity": "sha512-ztqyC3kLto0e9WbNp0aeP+M3kTt+nbaIveGmUxAtZa+8iFgKLUOD4YKM5j+f3QD89bra7UeumolZHKuOXnTmeQ==", "engines": { "node": ">=8" }, @@ -7435,9 +7936,9 @@ } }, "node_modules/html-webpack-plugin": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-5.5.0.tgz", - "integrity": "sha512-sy88PC2cRTVxvETRgUHFrL4No3UxvcH8G1NepGhqaTT+GXN2kTamqasot0inS5hXeg1cMbFDt27zzo9p35lZVw==", + "version": "5.5.3", + "resolved": "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-5.5.3.tgz", + "integrity": "sha512-6YrDKTuqaP/TquFH7h4srYWsZx+x6k6+FbsTm0ziCwGHDP78Unr1r9F/H4+sGmMbX08GQcJ+K64x55b+7VM/jg==", "dependencies": { "@types/html-minifier-terser": "^6.0.0", "html-minifier-terser": "^6.0.2", @@ -7457,9 +7958,9 @@ } }, "node_modules/htmlparser2": { - "version": "8.0.1", - "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.1.tgz", - "integrity": "sha512-4lVbmc1diZC7GUJQtRQ5yBAeUCL1exyMwmForWkRLnwyzWBFxN633SALPMGYaWZvKe9j1pRZJpauvmxENSp/EA==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.1.0.tgz", + "integrity": "sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==", "funding": [ "https://github.com/fb55/htmlparser2?sponsor=1", { @@ -7468,19 +7969,16 @@ } ], "dependencies": { - "domelementtype": "^2.3.0", - "domhandler": "^5.0.2", - "domutils": "^3.0.1", - "entities": "^4.3.0" + "domelementtype": "^2.0.1", + "domhandler": "^4.0.0", + "domutils": "^2.5.2", + "entities": "^2.0.0" } }, "node_modules/htmlparser2/node_modules/entities": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/entities/-/entities-4.3.1.tgz", - "integrity": "sha512-o4q/dYJlmyjP2zfnaWDUC6A3BQFmVTX+tZPezK7k0GLSU9QYCauscf5Y+qcEPzKL+EixVouYDgLQK5H9GrLpkg==", - "engines": { - "node": ">=0.12" - }, + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", + "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==", "funding": { "url": "https://github.com/fb55/entities?sponsor=1" } @@ -7529,9 +8027,9 @@ } }, "node_modules/http-proxy-middleware": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.6.tgz", - "integrity": "sha512-ya/UeJ6HVBYxrgYotAZo1KvPWlgB48kUJLDePFeneHsVujFaW5WNj2NgWCAE//B1Dl02BIfYlpNgBy8Kf8Rjmw==", + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.7.tgz", + "integrity": "sha512-fgVY8AV7qU7z/MmXJ/rxwbrtQH4jBQ9m7kp3llF0liB7glmFeVZFBepQb32T3y8n8k2+AEYuMPCpinYW+/CuRA==", "dependencies": { "@types/http-proxy": "^1.17.8", "http-proxy": "^1.18.1", @@ -7551,17 +8049,6 @@ } } }, - "node_modules/http-proxy-middleware/node_modules/is-plain-obj": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-3.0.0.tgz", - "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==", - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/human-signals": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", @@ -7601,9 +8088,9 @@ } }, "node_modules/image-size": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/image-size/-/image-size-1.0.2.tgz", - "integrity": "sha512-xfOoWjceHntRb3qFCrh5ZFORYH8XCdYpASltMhZ/Q0KZiOwjdE/Yl2QCiWdwD+lygV5bMCvauzgu5PxBX/Yerg==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/image-size/-/image-size-1.1.1.tgz", + "integrity": "sha512-541xKlUw6jr/6gGuk92F+mYM5zaFAc5ahphvkqvNe2bQ6gVBkd6bfrmVJ2t4KDAfikAYZyIqTnktX3i6/aQDrQ==", "dependencies": { "queue": "6.0.2" }, @@ -7611,7 +8098,7 @@ "image-size": "bin/image-size.js" }, "engines": { - "node": ">=14.0.0" + "node": ">=16.x" } }, "node_modules/immer": { @@ -7717,9 +8204,9 @@ } }, "node_modules/ipaddr.js": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.0.1.tgz", - "integrity": "sha512-1qTgH9NG+IIJ4yfKs2e6Pp1bZg8wbDbKHT21HrLIeYBTRLgMYKnMTPAuI3Lcs61nfx5h1xlXnbJtH1kX5/d/ng==", + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.1.0.tgz", + "integrity": "sha512-LlbxQ7xKzfBusov6UMi4MFpEg0m+mAm9xyNGEduwXMEDuf4WfzB/RZwMVYEd7IKGvh4IUkEXYxtAVu9T3OelJQ==", "engines": { "node": ">= 10" } @@ -7795,6 +8282,11 @@ "is-ci": "bin.js" } }, + "node_modules/is-ci/node_modules/ci-info": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz", + "integrity": "sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==" + }, "node_modules/is-core-module": { "version": "2.9.0", "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.9.0.tgz", @@ -7932,11 +8424,14 @@ } }, "node_modules/is-plain-obj": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", - "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-3.0.0.tgz", + "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==", "engines": { - "node": ">=8" + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/is-plain-object": { @@ -8034,6 +8529,22 @@ "node": ">=0.10.0" } }, + "node_modules/jest-util": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-29.7.0.tgz", + "integrity": "sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==", + "dependencies": { + "@jest/types": "^29.6.3", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, "node_modules/jest-worker": { "version": "27.5.1", "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz", @@ -8061,15 +8572,23 @@ "url": "https://github.com/chalk/supports-color?sponsor=1" } }, + "node_modules/jiti": { + "version": "1.21.0", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.0.tgz", + "integrity": "sha512-gFqAIbuKyyso/3G2qhiO2OM6shY6EPP/R0+mkDbyspxKazh8BXDC5FiFsUjlczgdNz/vfra0da2y+aHrusLG/Q==", + "bin": { + "jiti": "bin/jiti.js" + } + }, "node_modules/joi": { - "version": "17.6.0", - "resolved": "https://registry.npmjs.org/joi/-/joi-17.6.0.tgz", - "integrity": "sha512-OX5dG6DTbcr/kbMFj0KGYxuew69HPcAE3K/sZpEV2nP6e/j/C0HV+HNiBPCASxdx5T7DMoa0s8UeHWMnb6n2zw==", + "version": "17.11.0", + "resolved": "https://registry.npmjs.org/joi/-/joi-17.11.0.tgz", + "integrity": "sha512-NgB+lZLNoqISVy1rZocE9PZI36bL/77ie924Ri43yEvi9GUUMPeyVIr8KdFTMUlby1p0PBYMk9spIxEUQYqrJQ==", "dependencies": { "@hapi/hoek": "^9.0.0", "@hapi/topo": "^5.0.0", "@sideway/address": "^4.1.3", - "@sideway/formula": "^3.0.0", + "@sideway/formula": "^3.0.1", "@sideway/pinpoint": "^2.0.0" } }, @@ -8180,6 +8699,15 @@ "node": ">=8" } }, + "node_modules/launch-editor": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/launch-editor/-/launch-editor-2.6.1.tgz", + "integrity": "sha512-eB/uXmFVpY4zezmGp5XtU21kwo7GBbKB+EQ+UZeWtGb9yAM5xt/Evk+lYH3eRNAtId+ej4u7TYPFZ07w4s7rRw==", + "dependencies": { + "picocolors": "^1.0.0", + "shell-quote": "^1.8.1" + } + }, "node_modules/leven": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", @@ -8189,9 +8717,9 @@ } }, "node_modules/lilconfig": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.0.6.tgz", - "integrity": "sha512-9JROoBW7pobfsx+Sq2JsASvCo6Pfo6WWoUW79HuB1BCoBXD4PLWJPqDF6fNj67pqBYTbAHkE57M1kS/+L1neOg==", + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz", + "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==", "engines": { "node": ">=10" } @@ -8324,9 +8852,9 @@ } }, "node_modules/make-dir/node_modules/semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "bin": { "semver": "bin/semver.js" } @@ -8422,9 +8950,12 @@ } }, "node_modules/merge-descriptors": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz", - "integrity": "sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==" + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } }, "node_modules/merge-stream": { "version": "2.0.0", @@ -8448,11 +8979,11 @@ } }, "node_modules/micromatch": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", - "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", "dependencies": { - "braces": "^3.0.2", + "braces": "^3.0.3", "picomatch": "^2.3.1" }, "engines": { @@ -8505,23 +9036,10 @@ "node": ">=4" } }, - "node_modules/mini-create-react-context": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/mini-create-react-context/-/mini-create-react-context-0.4.1.tgz", - "integrity": "sha512-YWCYEmd5CQeHGSAKrYvXgmzzkrvssZcuuQDDeqkT+PziKGMgE+0MCCtcKbROzocGBG1meBLl2FotlRwf4gAzbQ==", - "dependencies": { - "@babel/runtime": "^7.12.1", - "tiny-warning": "^1.0.3" - }, - "peerDependencies": { - "prop-types": "^15.0.0", - "react": "^0.14.0 || ^15.0.0 || ^16.0.0 || ^17.0.0" - } - }, "node_modules/mini-css-extract-plugin": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.6.1.tgz", - "integrity": "sha512-wd+SD57/K6DiV7jIR34P+s3uckTRuQvx0tKPcvjFlrEylk6P4mQ2KSWk1hblj1Kxaqok7LogKOieygXqBczNlg==", + "version": "2.7.6", + "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.7.6.tgz", + "integrity": "sha512-Qk7HcgaPkGG6eD77mLvZS1nmxlao3j+9PkrT9Uc7HAE1id3F41+DdBRYRYkbyfNRGzm8/YWtzhw7nVPmwhqTQw==", "dependencies": { "schema-utils": "^4.0.0" }, @@ -8536,55 +9054,6 @@ "webpack": "^5.0.0" } }, - "node_modules/mini-css-extract-plugin/node_modules/ajv": { - "version": "8.11.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz", - "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==", - "dependencies": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/epoberezkin" - } - }, - "node_modules/mini-css-extract-plugin/node_modules/ajv-keywords": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", - "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", - "dependencies": { - "fast-deep-equal": "^3.1.3" - }, - "peerDependencies": { - "ajv": "^8.8.2" - } - }, - "node_modules/mini-css-extract-plugin/node_modules/json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" - }, - "node_modules/mini-css-extract-plugin/node_modules/schema-utils": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", - "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", - "dependencies": { - "@types/json-schema": "^7.0.9", - "ajv": "^8.8.0", - "ajv-formats": "^2.1.1", - "ajv-keywords": "^5.0.0" - }, - "engines": { - "node": ">= 12.13.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/webpack" - } - }, "node_modules/minimalistic-assert": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", @@ -8602,9 +9071,12 @@ } }, "node_modules/minimist": { - "version": "1.2.6", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz", - "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==" + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } }, "node_modules/mrmime": { "version": "1.0.1", @@ -8632,9 +9104,15 @@ } }, "node_modules/nanoid": { - "version": "3.3.4", - "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.4.tgz", - "integrity": "sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw==", + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz", + "integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], "bin": { "nanoid": "bin/nanoid.cjs" }, @@ -8673,9 +9151,9 @@ } }, "node_modules/node-fetch": { - "version": "2.6.7", - "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz", - "integrity": "sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==", + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", + "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==", "dependencies": { "whatwg-url": "^5.0.0" }, @@ -8700,9 +9178,9 @@ } }, "node_modules/node-releases": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.6.tgz", - "integrity": "sha512-PiVXnNuFm5+iYkLBNeq5211hvO38y63T0i2KKh2KnUs3RpzJ+JtODFjkD8yjLwnDkTYF1eKXheUwdssR+NRZdg==" + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.14.tgz", + "integrity": "sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==" }, "node_modules/normalize-path": { "version": "3.0.0", @@ -8767,9 +9245,12 @@ } }, "node_modules/object-inspect": { - "version": "1.12.2", - "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.2.tgz", - "integrity": "sha512-z+cPxW0QGUp0mcqcsgQyLVRDoXFQbXOwBaqyF7VIgI4TWNQsDHrBpUQslRmIfAoYWdYzs6UlKJtB2XJpTaNSpQ==", + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.2.tgz", + "integrity": "sha512-IRZSRuzJiynemAXPYtPe5BoI/RESNYR7TYm50MC5Mqbd3Jmw5y790sErYw3V6SryFJD64b74qQQs9wn5Bg/k3g==", + "engines": { + "node": ">= 0.4" + }, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -8959,9 +9440,9 @@ } }, "node_modules/package-json/node_modules/semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "bin": { "semver": "bin/semver.js" } @@ -9026,11 +9507,11 @@ "integrity": "sha512-twN+njEipszzlMJd4ONUYgSfZPDxgHhT9Ahed5uTigpQn90FggW4SA/AIPq/6a149fTbE9qBEcSwE3FAEp6wQQ==" }, "node_modules/parse5": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.0.0.tgz", - "integrity": "sha512-y/t8IXSPWTuRZqXc0ajH/UwDj4mnqLEbSttNbThcFhGrZuOyoyvNBO85PBp2jQa55wY9d07PBNjsK8ZP3K5U6g==", + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.1.2.tgz", + "integrity": "sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==", "dependencies": { - "entities": "^4.3.0" + "entities": "^4.4.0" }, "funding": { "url": "https://github.com/inikulin/parse5?sponsor=1" @@ -9048,15 +9529,18 @@ "url": "https://github.com/inikulin/parse5?sponsor=1" } }, - "node_modules/parse5/node_modules/entities": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/entities/-/entities-4.3.1.tgz", - "integrity": "sha512-o4q/dYJlmyjP2zfnaWDUC6A3BQFmVTX+tZPezK7k0GLSU9QYCauscf5Y+qcEPzKL+EixVouYDgLQK5H9GrLpkg==", + "node_modules/parse5-htmlparser2-tree-adapter/node_modules/domhandler": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "dependencies": { + "domelementtype": "^2.3.0" + }, "engines": { - "node": ">=0.12" + "node": ">= 4" }, "funding": { - "url": "https://github.com/fb55/entities?sponsor=1" + "url": "https://github.com/fb55/domhandler?sponsor=1" } }, "node_modules/parseurl": { @@ -9207,9 +9691,9 @@ } }, "node_modules/postcss": { - "version": "8.4.14", - "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.14.tgz", - "integrity": "sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==", + "version": "8.4.31", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.31.tgz", + "integrity": "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==", "funding": [ { "type": "opencollective", @@ -9218,10 +9702,14 @@ { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" } ], "dependencies": { - "nanoid": "^3.3.4", + "nanoid": "^3.3.6", "picocolors": "^1.0.0", "source-map-js": "^1.0.2" }, @@ -9242,11 +9730,11 @@ } }, "node_modules/postcss-colormin": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-5.3.0.tgz", - "integrity": "sha512-WdDO4gOFG2Z8n4P8TWBpshnL3JpmNmJwdnfP2gbk2qBA8PWwOYcmjmI/t3CmMeL72a7Hkd+x/Mg9O2/0rD54Pg==", + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-5.3.1.tgz", + "integrity": "sha512-UsWQG0AqTFQmpBegeLLc1+c3jIqBNB0zlDGRWR+dQ3pRKJL1oeMzyqmH3o2PIfn9MBdNrVPWhDbT769LxCTLJQ==", "dependencies": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "caniuse-api": "^3.0.0", "colord": "^2.9.1", "postcss-value-parser": "^4.2.0" @@ -9259,11 +9747,11 @@ } }, "node_modules/postcss-convert-values": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-5.1.2.tgz", - "integrity": "sha512-c6Hzc4GAv95B7suy4udszX9Zy4ETyMCgFPUDtWjdFTKH1SE9eFY/jEpHSwTH1QPuwxHpWslhckUQWbNRM4ho5g==", + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-5.1.3.tgz", + "integrity": "sha512-82pC1xkJZtcJEfiLw6UXnXVXScgtBrjlO5CBmuDQc+dlb88ZYheFsjTn40+zBVi3DkfF7iezO0nJUPLcJK3pvA==", "dependencies": { - "browserslist": "^4.20.3", + "browserslist": "^4.21.4", "postcss-value-parser": "^4.2.0" }, "engines": { @@ -9332,13 +9820,13 @@ } }, "node_modules/postcss-loader": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/postcss-loader/-/postcss-loader-7.0.1.tgz", - "integrity": "sha512-VRviFEyYlLjctSM93gAZtcJJ/iSkPZ79zWbN/1fSH+NisBByEiVLqpdVDrPLVSi8DX0oJo12kL/GppTBdKVXiQ==", + "version": "7.3.3", + "resolved": "https://registry.npmjs.org/postcss-loader/-/postcss-loader-7.3.3.tgz", + "integrity": "sha512-YgO/yhtevGO/vJePCQmTxiaEwER94LABZN0ZMT4A0vsak9TpO+RvKRs7EmJ8peIlB9xfXCsS7M8LjqncsUZ5HA==", "dependencies": { - "cosmiconfig": "^7.0.0", - "klona": "^2.0.5", - "semver": "^7.3.7" + "cosmiconfig": "^8.2.0", + "jiti": "^1.18.2", + "semver": "^7.3.8" }, "engines": { "node": ">= 14.15.0" @@ -9352,6 +9840,31 @@ "webpack": "^5.0.0" } }, + "node_modules/postcss-loader/node_modules/cosmiconfig": { + "version": "8.3.6", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-8.3.6.tgz", + "integrity": "sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==", + "dependencies": { + "import-fresh": "^3.3.0", + "js-yaml": "^4.1.0", + "parse-json": "^5.2.0", + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/d-fischer" + }, + "peerDependencies": { + "typescript": ">=4.9.5" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, "node_modules/postcss-merge-idents": { "version": "5.1.1", "resolved": "https://registry.npmjs.org/postcss-merge-idents/-/postcss-merge-idents-5.1.1.tgz", @@ -9368,12 +9881,12 @@ } }, "node_modules/postcss-merge-longhand": { - "version": "5.1.6", - "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-5.1.6.tgz", - "integrity": "sha512-6C/UGF/3T5OE2CEbOuX7iNO63dnvqhGZeUnKkDeifebY0XqkkvrctYSZurpNE902LDf2yKwwPFgotnfSoPhQiw==", + "version": "5.1.7", + "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-5.1.7.tgz", + "integrity": "sha512-YCI9gZB+PLNskrK0BB3/2OzPnGhPkBEwmwhfYk1ilBHYVAZB7/tkTHFBAnCrvBBOmeYyMYw3DMjT55SyxMBzjQ==", "dependencies": { "postcss-value-parser": "^4.2.0", - "stylehacks": "^5.1.0" + "stylehacks": "^5.1.1" }, "engines": { "node": "^10 || ^12 || >=14.0" @@ -9383,11 +9896,11 @@ } }, "node_modules/postcss-merge-rules": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-5.1.2.tgz", - "integrity": "sha512-zKMUlnw+zYCWoPN6yhPjtcEdlJaMUZ0WyVcxTAmw3lkkN/NDMRkOkiuctQEoWAOvH7twaxUUdvBWl0d4+hifRQ==", + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-5.1.4.tgz", + "integrity": "sha512-0R2IuYpgU93y9lhVbO/OylTtKMVcHb67zjWIfCiKR9rWL3GUk1677LAqD/BcHizukdZEjT8Ru3oHRoAYoJy44g==", "dependencies": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "caniuse-api": "^3.0.0", "cssnano-utils": "^3.1.0", "postcss-selector-parser": "^6.0.5" @@ -9430,11 +9943,11 @@ } }, "node_modules/postcss-minify-params": { - "version": "5.1.3", - "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-5.1.3.tgz", - "integrity": "sha512-bkzpWcjykkqIujNL+EVEPOlLYi/eZ050oImVtHU7b4lFS82jPnsCb44gvC6pxaNt38Els3jWYDHTjHKf0koTgg==", + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-5.1.4.tgz", + "integrity": "sha512-+mePA3MgdmVmv6g+30rn57USjOGSAyuxUmkfiWpzalZ8aiBkdPYjXWtHuwJGm1v5Ojy0Z0LaSYhHaLJQB0P8Jw==", "dependencies": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "cssnano-utils": "^3.1.0", "postcss-value-parser": "^4.2.0" }, @@ -9471,9 +9984,9 @@ } }, "node_modules/postcss-modules-local-by-default": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.0.0.tgz", - "integrity": "sha512-sT7ihtmGSF9yhm6ggikHdV0hlziDTX7oFoXtuVWeDd3hHObNkcHRo9V3yg7vCAY7cONyxJC/XXCmmiHHcvX7bQ==", + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.0.3.tgz", + "integrity": "sha512-2/u2zraspoACtrbFRnTijMiQtb4GW4BvatjaG/bCjYQo8kLTdevCUlwuBHx2sCnSyrI3x3qj4ZK1j5LQBgzmwA==", "dependencies": { "icss-utils": "^5.0.0", "postcss-selector-parser": "^6.0.2", @@ -9596,11 +10109,11 @@ } }, "node_modules/postcss-normalize-unicode": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-5.1.0.tgz", - "integrity": "sha512-J6M3MizAAZ2dOdSjy2caayJLQT8E8K9XjLce8AUQMwOrCvjCHv24aLC/Lps1R1ylOfol5VIDMaM/Lo9NGlk1SQ==", + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-5.1.1.tgz", + "integrity": "sha512-qnCL5jzkNUmKVhZoENp1mJiGNPcsJCs1aaRmURmeJGES23Z/ajaln+EPTD+rBeNkSryI+2WTdW+lwcVdOikrpA==", "dependencies": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "postcss-value-parser": "^4.2.0" }, "engines": { @@ -9669,11 +10182,11 @@ } }, "node_modules/postcss-reduce-initial": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-5.1.0.tgz", - "integrity": "sha512-5OgTUviz0aeH6MtBjHfbr57tml13PuedK/Ecg8szzd4XRMbYxH4572JFG067z+FqBIf6Zp/d+0581glkvvWMFw==", + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-5.1.2.tgz", + "integrity": "sha512-dE/y2XRaqAi6OvjzD22pjTUQ8eOfc6m/natGHgKFBK9DxFmIm69YmaRVQrGgFlEfc1HePIurY0TmDeROK05rIg==", "dependencies": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "caniuse-api": "^3.0.0" }, "engines": { @@ -9698,9 +10211,9 @@ } }, "node_modules/postcss-selector-parser": { - "version": "6.0.10", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz", - "integrity": "sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==", + "version": "6.0.13", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.13.tgz", + "integrity": "sha512-EaV1Gl4mUEV4ddhDnv/xtj7sxwrwxdetHdWUGnT4VJQf+4d05v6lHYZr8N573k5Z0BViss7BDhfWtKS3+sfAqQ==", "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" @@ -9710,17 +10223,17 @@ } }, "node_modules/postcss-sort-media-queries": { - "version": "4.2.1", - "resolved": "https://registry.npmjs.org/postcss-sort-media-queries/-/postcss-sort-media-queries-4.2.1.tgz", - "integrity": "sha512-9VYekQalFZ3sdgcTjXMa0dDjsfBVHXlraYJEMiOJ/2iMmI2JGCMavP16z3kWOaRu8NSaJCTgVpB/IVpH5yT9YQ==", + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/postcss-sort-media-queries/-/postcss-sort-media-queries-4.4.1.tgz", + "integrity": "sha512-QDESFzDDGKgpiIh4GYXsSy6sek2yAwQx1JASl5AxBtU1Lq2JfKBljIPNdil989NcSKRQX1ToiaKphImtBuhXWw==", "dependencies": { - "sort-css-media-queries": "2.0.4" + "sort-css-media-queries": "2.1.0" }, "engines": { "node": ">=10.0.0" }, "peerDependencies": { - "postcss": "^8.4.4" + "postcss": "^8.4.16" } }, "node_modules/postcss-svgo": { @@ -9802,9 +10315,9 @@ } }, "node_modules/prismjs": { - "version": "1.28.0", - "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.28.0.tgz", - "integrity": "sha512-8aaXdYvl1F7iC7Xm1spqSaY/OJBpYW3v+KJ+F17iYxvdc8sfjW194COK5wVhMZX45tGteiBQgdvD/nhxcRwylw==", + "version": "1.29.0", + "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.29.0.tgz", + "integrity": "sha512-Kx/1w86q/epKcmte75LNrEoT+lX8pBpavuAbvJWRXar7Hz8jrtF+e3vY751p0R8H9HdArwaCTNDDzHg/ScJK1Q==", "engines": { "node": ">=6" } @@ -9907,11 +10420,11 @@ "integrity": "sha512-QFADYnsVoBMw1srW7OVKEYjG+MbIa49s54w1MA1EDY6r2r/sTcKKYqRX1f4GYvnXP7eN/Pe9HFcX+hwzmrXRHA==" }, "node_modules/qs": { - "version": "6.10.3", - "resolved": "https://registry.npmjs.org/qs/-/qs-6.10.3.tgz", - "integrity": "sha512-wr7M2E0OFRfIfJZjKGieI8lBKb7fRCH4Fv5KNPEs7gJ8jadvotdsS08PzOKR7opXhZ/Xkjtt3WF9g38drmyRqQ==", + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz", + "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==", "dependencies": { - "side-channel": "^1.0.4" + "side-channel": "^1.0.6" }, "engines": { "node": ">=0.6" @@ -9964,9 +10477,9 @@ } }, "node_modules/raw-body": { - "version": "2.5.1", - "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.1.tgz", - "integrity": "sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==", + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz", + "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==", "dependencies": { "bytes": "3.1.2", "http-errors": "2.0.0", @@ -10272,15 +10785,14 @@ } }, "node_modules/react-router": { - "version": "5.3.3", - "resolved": "https://registry.npmjs.org/react-router/-/react-router-5.3.3.tgz", - "integrity": "sha512-mzQGUvS3bM84TnbtMYR8ZjKnuPJ71IjSzR+DE6UkUqvN4czWIqEs17yLL8xkAycv4ev0AiN+IGrWu88vJs/p2w==", + "version": "5.3.4", + "resolved": "https://registry.npmjs.org/react-router/-/react-router-5.3.4.tgz", + "integrity": "sha512-Ys9K+ppnJah3QuaRiLxk+jDWOR1MekYQrlytiXxC1RyfbdsZkS5pvKAzCCr031xHixZwpnsYNT5xysdFHQaYsA==", "dependencies": { "@babel/runtime": "^7.12.13", "history": "^4.9.0", "hoist-non-react-statics": "^3.1.0", "loose-envify": "^1.3.1", - "mini-create-react-context": "^0.4.0", "path-to-regexp": "^1.7.0", "prop-types": "^15.6.2", "react-is": "^16.6.0", @@ -10304,15 +10816,15 @@ } }, "node_modules/react-router-dom": { - "version": "5.3.3", - "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-5.3.3.tgz", - "integrity": "sha512-Ov0tGPMBgqmbu5CDmN++tv2HQ9HlWDuWIIqn4b88gjlAN5IHI+4ZUZRcpz9Hl0azFIwihbLDYw1OiHGRo7ZIng==", + "version": "5.3.4", + "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-5.3.4.tgz", + "integrity": "sha512-m4EqFMHv/Ih4kpcBCONHbkT68KoAeHN4p3lAGoNryfHi0dMy0kCzEZakiKRsvg5wHZ/JLrLW8o8KomWiz/qbYQ==", "dependencies": { "@babel/runtime": "^7.12.13", "history": "^4.9.0", "loose-envify": "^1.3.1", "prop-types": "^15.6.2", - "react-router": "5.3.3", + "react-router": "5.3.4", "tiny-invariant": "^1.0.2", "tiny-warning": "^1.0.0" }, @@ -10330,11 +10842,11 @@ } }, "node_modules/react-textarea-autosize": { - "version": "8.3.4", - "resolved": "https://registry.npmjs.org/react-textarea-autosize/-/react-textarea-autosize-8.3.4.tgz", - "integrity": "sha512-CdtmP8Dc19xL8/R6sWvtknD/eCXkQr30dtvC4VmGInhRsfF8X/ihXCq6+9l9qbxmKRiq407/7z5fxE7cVWQNgQ==", + "version": "8.5.3", + "resolved": "https://registry.npmjs.org/react-textarea-autosize/-/react-textarea-autosize-8.5.3.tgz", + "integrity": "sha512-XT1024o2pqCuZSuBt9FwHlaDeNtVrtCXu0Rnz88t1jUGheCLa3PhjE1GH8Ctm2axEtvdCl5SUHYschyQ0L5QHQ==", "dependencies": { - "@babel/runtime": "^7.10.2", + "@babel/runtime": "^7.20.13", "use-composed-ref": "^1.3.0", "use-latest": "^1.2.1" }, @@ -10346,9 +10858,9 @@ } }, "node_modules/readable-stream": { - "version": "3.6.0", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", - "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", @@ -10402,9 +10914,9 @@ "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==" }, "node_modules/regenerate-unicode-properties": { - "version": "10.0.1", - "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.0.1.tgz", - "integrity": "sha512-vn5DU6yg6h8hP/2OkQo3K7uVILvY4iu0oI4t3HFa81UPkhGJwkRwM10JEc3upjdhHjs/k8GJY1sRBhk5sr69Bw==", + "version": "10.1.1", + "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.1.1.tgz", + "integrity": "sha512-X007RyZLsCJVVrjgEFVpLUTZwyOZk3oiL75ZcuYjlIWd6rNJtOjkBwQc5AsRrpbKVkxN6sklw/k/9m2jJYOf8Q==", "dependencies": { "regenerate": "^1.4.2" }, @@ -10413,29 +10925,29 @@ } }, "node_modules/regenerator-runtime": { - "version": "0.13.9", - "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.9.tgz", - "integrity": "sha512-p3VT+cOEgxFsRRA9X4lkI1E+k2/CtnKtU4gcxyaCUreilL/vqI6CdZ3wxVUx3UOUg+gnUOQQcRI7BmSI656MYA==" + "version": "0.14.0", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.0.tgz", + "integrity": "sha512-srw17NI0TUWHuGa5CFGGmhfNIeja30WMBfbslPNhf6JrqQlLN5gcrvig1oqPxiVaXb0oW0XRKtH6Nngs5lKCIA==" }, "node_modules/regenerator-transform": { - "version": "0.15.0", - "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.15.0.tgz", - "integrity": "sha512-LsrGtPmbYg19bcPHwdtmXwbW+TqNvtY4riE3P83foeHRroMbH6/2ddFBfab3t7kbzc7v7p4wbkIecHImqt0QNg==", + "version": "0.15.2", + "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.15.2.tgz", + "integrity": "sha512-hfMp2BoF0qOk3uc5V20ALGDS2ddjQaLrdl7xrGXvAIow7qeWRM2VA2HuCHkUKk9slq3VwEwLNK3DFBqDfPGYtg==", "dependencies": { "@babel/runtime": "^7.8.4" } }, "node_modules/regexpu-core": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-5.1.0.tgz", - "integrity": "sha512-bb6hk+xWd2PEOkj5It46A16zFMs2mv86Iwpdu94la4S3sJ7C973h2dHpYKwIBGaWSO7cIRJ+UX0IeMaWcO4qwA==", + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-5.3.2.tgz", + "integrity": "sha512-RAM5FlZz+Lhmo7db9L298p2vHP5ZywrVXmVXpmAD9GuL5MPH6t9ROw1iA/wfHkQ76Qe7AaPF0nGuim96/IrQMQ==", "dependencies": { + "@babel/regjsgen": "^0.8.0", "regenerate": "^1.4.2", - "regenerate-unicode-properties": "^10.0.1", - "regjsgen": "^0.6.0", - "regjsparser": "^0.8.2", + "regenerate-unicode-properties": "^10.1.0", + "regjsparser": "^0.9.1", "unicode-match-property-ecmascript": "^2.0.0", - "unicode-match-property-value-ecmascript": "^2.0.0" + "unicode-match-property-value-ecmascript": "^2.1.0" }, "engines": { "node": ">=4" @@ -10464,14 +10976,14 @@ } }, "node_modules/regjsgen": { - "version": "0.6.0", - "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.6.0.tgz", - "integrity": "sha512-ozE883Uigtqj3bx7OhL1KNbCzGyW2NQZPl6Hs09WTvCuZD5sTI4JY58bkbQWa/Y9hxIsvJ3M8Nbf7j54IqeZbA==" + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.2.tgz", + "integrity": "sha512-OFFT3MfrH90xIW8OOSyUrk6QHD5E9JOTeGodiJeBS3J6IwlgzJMNE/1bZklWz5oTg+9dCMyEetclvCVXOPoN3A==" }, "node_modules/regjsparser": { - "version": "0.8.4", - "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.8.4.tgz", - "integrity": "sha512-J3LABycON/VNEu3abOviqGHuB/LOtOQj8SKmfP9anY5GfAVw/SPjwzSjxGjbZXIxbGfqTHtJw58C2Li/WkStmA==", + "version": "0.9.1", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.9.1.tgz", + "integrity": "sha512-dQUtn90WanSNl+7mQKcXAgZxvUe7Z0SqXlgzv0za4LwiUhyzBC58yQO3liFoUgu8GiJVInAhJjkj1N0EtQ5nkQ==", "dependencies": { "jsesc": "~0.5.0" }, @@ -10577,19 +11089,6 @@ "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.10.4.tgz", "integrity": "sha512-O4KCvQA6lLiMU9l2eawBPMf1xPP8xPfB3iEQw150hOVTqj/rfXz0ThTb4HEzqQfs2Bmo5Ay8BzxfzVtBrr9dVg==" }, - "node_modules/remark-mdx/node_modules/@babel/plugin-proposal-object-rest-spread": { - "version": "7.12.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.12.1.tgz", - "integrity": "sha512-s6SowJIjzlhx8o7lsFx5zmY4At6CTtDvgNQDdPzkBQucle58A6b/TTeEBYtyDgmcXjUTM+vE8YOGHZzzbc/ioA==", - "dependencies": { - "@babel/helper-plugin-utils": "^7.10.4", - "@babel/plugin-syntax-object-rest-spread": "^7.8.0", - "@babel/plugin-transform-parameters": "^7.12.1" - }, - "peerDependencies": { - "@babel/core": "^7.0.0-0" - } - }, "node_modules/remark-mdx/node_modules/@babel/plugin-syntax-jsx": { "version": "7.12.1", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.12.1.tgz", @@ -10601,10 +11100,23 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/remark-mdx/node_modules/convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==" + }, + "node_modules/remark-mdx/node_modules/is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "engines": { + "node": ">=8" + } + }, "node_modules/remark-mdx/node_modules/semver": { - "version": "5.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", - "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", + "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", "bin": { "semver": "bin/semver" } @@ -10685,87 +11197,6 @@ "strip-ansi": "^6.0.1" } }, - "node_modules/renderkid/node_modules/css-select": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz", - "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==", - "dependencies": { - "boolbase": "^1.0.0", - "css-what": "^6.0.1", - "domhandler": "^4.3.1", - "domutils": "^2.8.0", - "nth-check": "^2.0.1" - }, - "funding": { - "url": "https://github.com/sponsors/fb55" - } - }, - "node_modules/renderkid/node_modules/dom-serializer": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz", - "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==", - "dependencies": { - "domelementtype": "^2.0.1", - "domhandler": "^4.2.0", - "entities": "^2.0.0" - }, - "funding": { - "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" - } - }, - "node_modules/renderkid/node_modules/domhandler": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz", - "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==", - "dependencies": { - "domelementtype": "^2.2.0" - }, - "engines": { - "node": ">= 4" - }, - "funding": { - "url": "https://github.com/fb55/domhandler?sponsor=1" - } - }, - "node_modules/renderkid/node_modules/domutils": { - "version": "2.8.0", - "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz", - "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==", - "dependencies": { - "dom-serializer": "^1.0.1", - "domelementtype": "^2.2.0", - "domhandler": "^4.2.0" - }, - "funding": { - "url": "https://github.com/fb55/domutils?sponsor=1" - } - }, - "node_modules/renderkid/node_modules/entities": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", - "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==", - "funding": { - "url": "https://github.com/fb55/entities?sponsor=1" - } - }, - "node_modules/renderkid/node_modules/htmlparser2": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.1.0.tgz", - "integrity": "sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==", - "funding": [ - "https://github.com/fb55/htmlparser2?sponsor=1", - { - "type": "github", - "url": "https://github.com/sponsors/fb55" - } - ], - "dependencies": { - "domelementtype": "^2.0.1", - "domhandler": "^4.0.0", - "domutils": "^2.5.2", - "entities": "^2.0.0" - } - }, "node_modules/repeat-string": { "version": "1.6.1", "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", @@ -10962,9 +11393,9 @@ } }, "node_modules/rxjs": { - "version": "7.5.6", - "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.5.6.tgz", - "integrity": "sha512-dnyv2/YsXhnm461G+R/Pe5bWP41Nm6LBXEYWI6eiFP4fiwx6WRI/CD0zbdVAudd9xwLEF2IDcKXLHit0FYjUzw==", + "version": "7.8.1", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.1.tgz", + "integrity": "sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==", "dependencies": { "tslib": "^2.1.0" } @@ -11050,9 +11481,9 @@ } }, "node_modules/sax": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", - "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==" + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.3.0.tgz", + "integrity": "sha512-0s+oAmw9zLl1V1cS9BtZN7JAd0cW5e0QH4W3LWEK6a4LaLEA2OTpGYWDY+6XasBLtz6wkm3u1xRw95mRuJ59WA==" }, "node_modules/scheduler": { "version": "0.19.1", @@ -11064,22 +11495,60 @@ } }, "node_modules/schema-utils": { - "version": "2.7.1", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.1.tgz", - "integrity": "sha512-SHiNtMOUGWBQJwzISiVYKu82GiV4QYGePp3odlY1tuKO7gPtphAT5R/py0fA6xtbgLL/RvtJZnU9b8s0F1q0Xg==", + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.2.0.tgz", + "integrity": "sha512-L0jRsrPpjdckP3oPug3/VxNKt2trR8TcabrM6FOAAlvC/9Phcmm+cuAgTlxBqdBR1WJx7Naj9WHw+aOmheSVbw==", "dependencies": { - "@types/json-schema": "^7.0.5", - "ajv": "^6.12.4", - "ajv-keywords": "^3.5.2" + "@types/json-schema": "^7.0.9", + "ajv": "^8.9.0", + "ajv-formats": "^2.1.1", + "ajv-keywords": "^5.1.0" }, "engines": { - "node": ">= 8.9.0" + "node": ">= 12.13.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/webpack" } }, + "node_modules/schema-utils/node_modules/ajv": { + "version": "8.12.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz", + "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/schema-utils/node_modules/ajv-keywords": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", + "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "dependencies": { + "fast-deep-equal": "^3.1.3" + }, + "peerDependencies": { + "ajv": "^8.8.2" + } + }, + "node_modules/schema-utils/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" + }, + "node_modules/search-insights": { + "version": "2.13.0", + "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.13.0.tgz", + "integrity": "sha512-Orrsjf9trHHxFRuo9/rzm0KIWmgzE8RMlZMzuhZOJ01Rnz3D0YBAe+V6473t6/H6c7irs6Lt48brULAiRWb3Vw==", + "peer": true + }, "node_modules/section-matter": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/section-matter/-/section-matter-1.0.0.tgz", @@ -11098,10 +11567,11 @@ "integrity": "sha512-mEugaLK+YfkijB4fx0e6kImuJdCIt2LxCRcbEYPqRGCs4F2ogyfZU5IAZRdjCP8JPq2AtdNoC/Dux63d9Kiryg==" }, "node_modules/selfsigned": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-2.0.1.tgz", - "integrity": "sha512-LmME957M1zOsUhG+67rAjKfiWFox3SBxE/yymatMZsAx+oMrJ0YQ8AToOnyCm7xbeg2ep37IHLxdu0o2MavQOQ==", + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-2.4.1.tgz", + "integrity": "sha512-th5B4L2U+eGLq1TVh7zNRGBapioSORUeymIydxgFpwww9d2qyKvtuPU2jJuHvYAwwqi2Y596QBL3eEqcPEYL8Q==", "dependencies": { + "@types/node-forge": "^1.3.0", "node-forge": "^1" }, "engines": { @@ -11109,9 +11579,9 @@ } }, "node_modules/semver": { - "version": "7.3.7", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz", - "integrity": "sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==", + "version": "7.5.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz", + "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==", "dependencies": { "lru-cache": "^6.0.0" }, @@ -11134,17 +11604,17 @@ } }, "node_modules/semver-diff/node_modules/semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "bin": { "semver": "bin/semver.js" } }, "node_modules/send": { - "version": "0.18.0", - "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz", - "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==", + "version": "0.19.0", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz", + "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==", "dependencies": { "debug": "2.6.9", "depd": "2.0.0", @@ -11177,12 +11647,20 @@ "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" }, - "node_modules/send/node_modules/ms": { - "version": "2.1.3", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" - }, - "node_modules/send/node_modules/range-parser": { + "node_modules/send/node_modules/encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/send/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" + }, + "node_modules/send/node_modules/range-parser": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", @@ -11191,9 +11669,9 @@ } }, "node_modules/serialize-javascript": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz", - "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==", + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.1.tgz", + "integrity": "sha512-owoXEFjWRllis8/M1Q+Cw5k8ZH40e3zhp/ovX+Xr/vi1qj6QesbyXXViFbpNvWvPNAD62SutwEXavefrLJWj7w==", "dependencies": { "randombytes": "^2.1.0" } @@ -11289,19 +11767,35 @@ } }, "node_modules/serve-static": { - "version": "1.15.0", - "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz", - "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==", + "version": "1.16.2", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz", + "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==", "dependencies": { - "encodeurl": "~1.0.2", + "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "parseurl": "~1.3.3", - "send": "0.18.0" + "send": "0.19.0" }, "engines": { "node": ">= 0.8.0" } }, + "node_modules/set-function-length": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz", + "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==", + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/setimmediate": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz", @@ -11348,9 +11842,12 @@ } }, "node_modules/shell-quote": { - "version": "1.7.3", - "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.7.3.tgz", - "integrity": "sha512-Vpfqwm4EnqGdlsBFNmHhxhElJYrdfcxPThu+ryKS5J8L/fhAwLazFZtq+S+TWZ9ANj2piSQLGj6NQg+lKPmxrw==" + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.1.tgz", + "integrity": "sha512-6j1W9l1iAs/4xYBI1SYOVZyFcCis9b4KCLQ8fgAGG07QvzaRLVVRQvAy85yNmmZSjYjg4MWh4gNvlPujU/5LpA==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } }, "node_modules/shelljs": { "version": "0.8.5", @@ -11369,13 +11866,17 @@ } }, "node_modules/side-channel": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", - "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz", + "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==", "dependencies": { - "call-bind": "^1.0.0", - "get-intrinsic": "^1.0.2", - "object-inspect": "^1.9.0" + "call-bind": "^1.0.7", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.4", + "object-inspect": "^1.13.1" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -11387,13 +11888,13 @@ "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==" }, "node_modules/sirv": { - "version": "1.0.19", - "resolved": "https://registry.npmjs.org/sirv/-/sirv-1.0.19.tgz", - "integrity": "sha512-JuLThK3TnZG1TAKDwNIqNq6QA2afLOCcm+iE8D1Kj3GA40pSPsxQjjJl0J8X3tsR7T+CP1GavpzLwYkgVLWrZQ==", + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/sirv/-/sirv-2.0.3.tgz", + "integrity": "sha512-O9jm9BsID1P+0HOi81VpXPoDxYP374pkOLzACAoyUQ/3OUVndNpsz6wMnY2z+yOxzbllCKZrM+9QrWsv4THnyA==", "dependencies": { "@polka/url": "^1.0.0-next.20", "mrmime": "^1.0.0", - "totalist": "^1.0.0" + "totalist": "^3.0.0" }, "engines": { "node": ">= 10" @@ -11446,9 +11947,9 @@ } }, "node_modules/sort-css-media-queries": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/sort-css-media-queries/-/sort-css-media-queries-2.0.4.tgz", - "integrity": "sha512-PAIsEK/XupCQwitjv7XxoMvYhT7EAfyzI3hsy/MyDgTvc+Ft55ctdkctJLOy6cQejaIC+zjpUL4djFVm2ivOOw==", + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/sort-css-media-queries/-/sort-css-media-queries-2.1.0.tgz", + "integrity": "sha512-IeWvo8NkNiY2vVYdPa27MCQiR0MN0M80johAYFVxWWXQ44KU84WNxjslwBHmc/7ZL2ccwkM7/e6S5aiKZXm7jA==", "engines": { "node": ">= 6.3.0" } @@ -11681,11 +12182,11 @@ } }, "node_modules/stylehacks": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-5.1.0.tgz", - "integrity": "sha512-SzLmvHQTrIWfSgljkQCw2++C9+Ne91d/6Sp92I8c5uHTcy/PgeHamwITIbBW9wnFTY/3ZfSXR9HIL6Ikqmcu6Q==", + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-5.1.1.tgz", + "integrity": "sha512-sBpcd5Hx7G6seo7b1LkpttvTz7ikD0LlH5RmdcBNb6fFR0Fl7LQwHDFr300q4cwUqi+IYrFGmsIHieMBfnN/Bw==", "dependencies": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "postcss-selector-parser": "^6.0.4" }, "engines": { @@ -11750,69 +12251,6 @@ "node": ">= 10" } }, - "node_modules/svgo/node_modules/css-select": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz", - "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==", - "dependencies": { - "boolbase": "^1.0.0", - "css-what": "^6.0.1", - "domhandler": "^4.3.1", - "domutils": "^2.8.0", - "nth-check": "^2.0.1" - }, - "funding": { - "url": "https://github.com/sponsors/fb55" - } - }, - "node_modules/svgo/node_modules/dom-serializer": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz", - "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==", - "dependencies": { - "domelementtype": "^2.0.1", - "domhandler": "^4.2.0", - "entities": "^2.0.0" - }, - "funding": { - "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" - } - }, - "node_modules/svgo/node_modules/domhandler": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz", - "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==", - "dependencies": { - "domelementtype": "^2.2.0" - }, - "engines": { - "node": ">= 4" - }, - "funding": { - "url": "https://github.com/fb55/domhandler?sponsor=1" - } - }, - "node_modules/svgo/node_modules/domutils": { - "version": "2.8.0", - "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz", - "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==", - "dependencies": { - "dom-serializer": "^1.0.1", - "domelementtype": "^2.2.0", - "domhandler": "^4.2.0" - }, - "funding": { - "url": "https://github.com/fb55/domutils?sponsor=1" - } - }, - "node_modules/svgo/node_modules/entities": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", - "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==", - "funding": { - "url": "https://github.com/fb55/entities?sponsor=1" - } - }, "node_modules/tapable": { "version": "2.2.1", "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz", @@ -11822,12 +12260,12 @@ } }, "node_modules/terser": { - "version": "5.14.2", - "resolved": "https://registry.npmjs.org/terser/-/terser-5.14.2.tgz", - "integrity": "sha512-oL0rGeM/WFQCUd0y2QrWxYnq7tfSuKBiqTjRPWrRgB46WD/kiwHwF8T23z78H6Q6kGCuuHcPB+KULHRdxvVGQA==", + "version": "5.31.6", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.31.6.tgz", + "integrity": "sha512-PQ4DAriWzKj+qgehQ7LK5bQqCFNMmlhjR2PFFLuqGCpuCAauxemVBWwWOxo3UIwWQx8+Pr61Df++r76wDmkQBg==", "dependencies": { - "@jridgewell/source-map": "^0.3.2", - "acorn": "^8.5.0", + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.8.2", "commander": "^2.20.0", "source-map-support": "~0.5.20" }, @@ -11839,15 +12277,15 @@ } }, "node_modules/terser-webpack-plugin": { - "version": "5.3.3", - "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.3.tgz", - "integrity": "sha512-Fx60G5HNYknNTNQnzQ1VePRuu89ZVYWfjRAeT5rITuCY/1b08s49e5kSQwHDirKZWuoKOBRFS98EUUoZ9kLEwQ==", + "version": "5.3.10", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz", + "integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==", "dependencies": { - "@jridgewell/trace-mapping": "^0.3.7", + "@jridgewell/trace-mapping": "^0.3.20", "jest-worker": "^27.4.5", "schema-utils": "^3.1.1", - "serialize-javascript": "^6.0.0", - "terser": "^5.7.2" + "serialize-javascript": "^6.0.1", + "terser": "^5.26.0" }, "engines": { "node": ">= 10.13.0" @@ -11889,9 +12327,9 @@ } }, "node_modules/terser/node_modules/acorn": { - "version": "8.7.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz", - "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==", + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz", + "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==", "bin": { "acorn": "bin/acorn" }, @@ -11981,9 +12419,9 @@ } }, "node_modules/totalist": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/totalist/-/totalist-1.1.0.tgz", - "integrity": "sha512-gduQwd1rOdDMGxFG1gEvhV88Oirdo2p+KjoYFU7k2g+i7n6AFFbDQ5kMPUsW0pNbfQsB/cwXvT1i4Bue0s9g5g==", + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz", + "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==", "engines": { "node": ">=6" } @@ -11996,7 +12434,8 @@ "node_modules/trim": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/trim/-/trim-0.0.1.tgz", - "integrity": "sha512-YzQV+TZg4AxpKxaTHK3c3D+kRDCGVEE7LemdlQZoQXn0iennk10RsIoY6ikzAqJTc9Xjl9C1/waHom/J86ziAQ==" + "integrity": "sha512-YzQV+TZg4AxpKxaTHK3c3D+kRDCGVEE7LemdlQZoQXn0iennk10RsIoY6ikzAqJTc9Xjl9C1/waHom/J86ziAQ==", + "deprecated": "Use String.prototype.trim() instead" }, "node_modules/trim-trailing-lines": { "version": "1.1.4", @@ -12017,9 +12456,9 @@ } }, "node_modules/tslib": { - "version": "2.4.0", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz", - "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==" + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz", + "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==" }, "node_modules/type-fest": { "version": "2.16.0", @@ -12072,22 +12511,22 @@ } }, "node_modules/typescript": { - "version": "4.7.4", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.7.4.tgz", - "integrity": "sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ==", + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz", + "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==", "peer": true, "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" }, "engines": { - "node": ">=4.2.0" + "node": ">=14.17" } }, "node_modules/ua-parser-js": { - "version": "0.7.33", - "resolved": "https://registry.npmjs.org/ua-parser-js/-/ua-parser-js-0.7.33.tgz", - "integrity": "sha512-s8ax/CeZdK9R/56Sui0WM6y9OFREJarMRHqLB2EwkovemBxNQ+Bqu8GAsUnVcXKgphb++ghr/B2BZx4mahujPw==", + "version": "1.0.37", + "resolved": "https://registry.npmjs.org/ua-parser-js/-/ua-parser-js-1.0.37.tgz", + "integrity": "sha512-bhTyI94tZofjo+Dn8SN6Zv8nBDvyXTymAdM3LDI/0IboIUwTu1rEhW7v2TfiVsoYWgkQ4kOVqnI8APUFbIQIFQ==", "funding": [ { "type": "opencollective", @@ -12096,6 +12535,10 @@ { "type": "paypal", "url": "https://paypal.me/faisalman" + }, + { + "type": "github", + "url": "https://github.com/sponsors/faisalman" } ], "engines": { @@ -12147,9 +12590,9 @@ } }, "node_modules/unicode-match-property-value-ecmascript": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.0.0.tgz", - "integrity": "sha512-7Yhkc0Ye+t4PNYzOGKedDhXbYIBe1XEQYQxOPyhcXNMJ0WCABqqj6ckydd6pWRZTHV4GuCPKdBAUiMc60tsKVw==", + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.1.0.tgz", + "integrity": "sha512-qxkjQt6qjg/mYscYMC0XKRn3Rh0wFPlfxB0xkt9CfyTvpX1Ra0+rAmdX2QyAobptSEvuy4RtpPRui6XkV+8wjA==", "engines": { "node": ">=4" } @@ -12179,6 +12622,14 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/unified/node_modules/is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "engines": { + "node": ">=8" + } + }, "node_modules/unique-string": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-2.0.0.tgz", @@ -12306,9 +12757,9 @@ } }, "node_modules/update-browserslist-db": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.4.tgz", - "integrity": "sha512-jnmO2BEGUjsMOe/Fg9u0oczOe/ppIDZPebzccl1yDWGLFP16Pa1/RM5wEoKYPG2zstNcDuAStejyxsOuKINdGA==", + "version": "1.0.13", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.13.tgz", + "integrity": "sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==", "funding": [ { "type": "opencollective", @@ -12317,6 +12768,10 @@ { "type": "tidelift", "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" } ], "dependencies": { @@ -12324,7 +12779,7 @@ "picocolors": "^1.0.0" }, "bin": { - "browserslist-lint": "cli.js" + "update-browserslist-db": "cli.js" }, "peerDependencies": { "browserslist": ">= 4.21.0" @@ -12571,6 +13026,14 @@ } } }, + "node_modules/use-sync-external-store": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.2.0.tgz", + "integrity": "sha512-eEgnFxGQ1Ife9bzYs6VLi8/4X6CObHMw9Qr9tPY43iKwsPw8xE8+EFsf/2cFZ5S3esXgpWgtSCtLNS41F+sKPA==", + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0" + } + }, "node_modules/util-deprecate": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", @@ -12679,9 +13142,9 @@ } }, "node_modules/watchpack": { - "version": "2.4.0", - "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.0.tgz", - "integrity": "sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==", + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz", + "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==", "dependencies": { "glob-to-regexp": "^0.4.1", "graceful-fs": "^4.1.2" @@ -12713,33 +13176,32 @@ "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==" }, "node_modules/webpack": { - "version": "5.76.1", - "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.76.1.tgz", - "integrity": "sha512-4+YIK4Abzv8172/SGqObnUjaIHjLEuUasz9EwQj/9xmPPkYJy2Mh03Q/lJfSD3YLzbxy5FeTq5Uw0323Oh6SJQ==", - "dependencies": { - "@types/eslint-scope": "^3.7.3", - "@types/estree": "^0.0.51", - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/wasm-edit": "1.11.1", - "@webassemblyjs/wasm-parser": "1.11.1", + "version": "5.94.0", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz", + "integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==", + "dependencies": { + "@types/estree": "^1.0.5", + "@webassemblyjs/ast": "^1.12.1", + "@webassemblyjs/wasm-edit": "^1.12.1", + "@webassemblyjs/wasm-parser": "^1.12.1", "acorn": "^8.7.1", - "acorn-import-assertions": "^1.7.6", - "browserslist": "^4.14.5", + "acorn-import-attributes": "^1.9.5", + "browserslist": "^4.21.10", "chrome-trace-event": "^1.0.2", - "enhanced-resolve": "^5.10.0", - "es-module-lexer": "^0.9.0", + "enhanced-resolve": "^5.17.1", + "es-module-lexer": "^1.2.1", "eslint-scope": "5.1.1", "events": "^3.2.0", "glob-to-regexp": "^0.4.1", - "graceful-fs": "^4.2.9", + "graceful-fs": "^4.2.11", "json-parse-even-better-errors": "^2.3.1", "loader-runner": "^4.2.0", "mime-types": "^2.1.27", "neo-async": "^2.6.2", - "schema-utils": "^3.1.0", + "schema-utils": "^3.2.0", "tapable": "^2.1.1", - "terser-webpack-plugin": "^5.1.3", - "watchpack": "^2.4.0", + "terser-webpack-plugin": "^5.3.10", + "watchpack": "^2.4.1", "webpack-sources": "^3.2.3" }, "bin": { @@ -12759,18 +13221,22 @@ } }, "node_modules/webpack-bundle-analyzer": { - "version": "4.5.0", - "resolved": "https://registry.npmjs.org/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.5.0.tgz", - "integrity": "sha512-GUMZlM3SKwS8Z+CKeIFx7CVoHn3dXFcUAjT/dcZQQmfSZGvitPfMob2ipjai7ovFFqPvTqkEZ/leL4O0YOdAYQ==", + "version": "4.10.0", + "resolved": "https://registry.npmjs.org/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.10.0.tgz", + "integrity": "sha512-j+apH0Cs+FY8IOIwxLbkgEJnbQgEPEG8uqLVnRb9tAoGbyKNxQA1u9wNDrTQHK3PinO4Pckew7AE7pnX/RS3wA==", "dependencies": { + "@discoveryjs/json-ext": "0.5.7", "acorn": "^8.0.4", "acorn-walk": "^8.0.0", - "chalk": "^4.1.0", "commander": "^7.2.0", + "debounce": "^1.2.1", + "escape-string-regexp": "^4.0.0", "gzip-size": "^6.0.0", - "lodash": "^4.17.20", + "html-escaper": "^2.0.2", + "is-plain-object": "^5.0.0", "opener": "^1.5.2", - "sirv": "^1.0.7", + "picocolors": "^1.0.0", + "sirv": "^2.0.3", "ws": "^7.3.1" }, "bin": { @@ -12781,9 +13247,9 @@ } }, "node_modules/webpack-bundle-analyzer/node_modules/acorn": { - "version": "8.7.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz", - "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==", + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz", + "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==", "bin": { "acorn": "bin/acorn" }, @@ -12799,10 +13265,18 @@ "node": ">= 10" } }, + "node_modules/webpack-bundle-analyzer/node_modules/is-plain-object": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz", + "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/webpack-dev-middleware": { - "version": "5.3.3", - "resolved": "https://registry.npmjs.org/webpack-dev-middleware/-/webpack-dev-middleware-5.3.3.tgz", - "integrity": "sha512-hj5CYrY0bZLB+eTO+x/j67Pkrquiy7kWepMHmUMoPsmcUaeEnQJqFzHJOyxgWlq746/wUuA64p9ta34Kyb01pA==", + "version": "5.3.4", + "resolved": "https://registry.npmjs.org/webpack-dev-middleware/-/webpack-dev-middleware-5.3.4.tgz", + "integrity": "sha512-BVdTqhhs+0IfoeAf7EoH5WE+exCmqGerHfDM0IL096Px60Tq2Mn9MAbnaGUe6HiMa41KMCYF19gyzZmBcq/o4Q==", "dependencies": { "colorette": "^2.0.10", "memfs": "^3.4.3", @@ -12821,37 +13295,6 @@ "webpack": "^4.0.0 || ^5.0.0" } }, - "node_modules/webpack-dev-middleware/node_modules/ajv": { - "version": "8.11.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz", - "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==", - "dependencies": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/epoberezkin" - } - }, - "node_modules/webpack-dev-middleware/node_modules/ajv-keywords": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", - "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", - "dependencies": { - "fast-deep-equal": "^3.1.3" - }, - "peerDependencies": { - "ajv": "^8.8.2" - } - }, - "node_modules/webpack-dev-middleware/node_modules/json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" - }, "node_modules/webpack-dev-middleware/node_modules/mime-db": { "version": "1.52.0", "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", @@ -12879,28 +13322,10 @@ "node": ">= 0.6" } }, - "node_modules/webpack-dev-middleware/node_modules/schema-utils": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", - "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", - "dependencies": { - "@types/json-schema": "^7.0.9", - "ajv": "^8.8.0", - "ajv-formats": "^2.1.1", - "ajv-keywords": "^5.0.0" - }, - "engines": { - "node": ">= 12.13.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/webpack" - } - }, "node_modules/webpack-dev-server": { - "version": "4.9.3", - "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.9.3.tgz", - "integrity": "sha512-3qp/eoboZG5/6QgiZ3llN8TUzkSpYg1Ko9khWX1h40MIEUNS2mDoIa8aXsPfskER+GbTvs/IJZ1QTBBhhuetSw==", + "version": "4.15.1", + "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.15.1.tgz", + "integrity": "sha512-5hbAst3h3C3L8w6W4P96L5vaV0PxSmJhxZvWKYIdgxOQm8pNZ5dEOmmSLBVpP85ReeyRt6AS1QJNyo/oFFPeVA==", "dependencies": { "@types/bonjour": "^3.5.9", "@types/connect-history-api-fallback": "^1.3.5", @@ -12908,7 +13333,7 @@ "@types/serve-index": "^1.9.1", "@types/serve-static": "^1.13.10", "@types/sockjs": "^0.3.33", - "@types/ws": "^8.5.1", + "@types/ws": "^8.5.5", "ansi-html-community": "^0.0.8", "bonjour-service": "^1.0.11", "chokidar": "^3.5.3", @@ -12921,16 +13346,17 @@ "html-entities": "^2.3.2", "http-proxy-middleware": "^2.0.3", "ipaddr.js": "^2.0.1", + "launch-editor": "^2.6.0", "open": "^8.0.9", "p-retry": "^4.5.0", "rimraf": "^3.0.2", "schema-utils": "^4.0.0", - "selfsigned": "^2.0.1", + "selfsigned": "^2.1.1", "serve-index": "^1.9.1", "sockjs": "^0.3.24", "spdy": "^4.0.2", "webpack-dev-middleware": "^5.3.1", - "ws": "^8.4.2" + "ws": "^8.13.0" }, "bin": { "webpack-dev-server": "bin/webpack-dev-server.js" @@ -12946,70 +13372,24 @@ "webpack": "^4.37.0 || ^5.0.0" }, "peerDependenciesMeta": { + "webpack": { + "optional": true + }, "webpack-cli": { "optional": true } } }, - "node_modules/webpack-dev-server/node_modules/ajv": { - "version": "8.11.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz", - "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==", - "dependencies": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/epoberezkin" - } - }, - "node_modules/webpack-dev-server/node_modules/ajv-keywords": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", - "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", - "dependencies": { - "fast-deep-equal": "^3.1.3" - }, - "peerDependencies": { - "ajv": "^8.8.2" - } - }, - "node_modules/webpack-dev-server/node_modules/json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" - }, - "node_modules/webpack-dev-server/node_modules/schema-utils": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", - "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", - "dependencies": { - "@types/json-schema": "^7.0.9", - "ajv": "^8.8.0", - "ajv-formats": "^2.1.1", - "ajv-keywords": "^5.0.0" - }, - "engines": { - "node": ">= 12.13.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/webpack" - } - }, "node_modules/webpack-dev-server/node_modules/ws": { - "version": "8.8.1", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.8.1.tgz", - "integrity": "sha512-bGy2JzvzkPowEJV++hF07hAD6niYSr0JzBNo/J29WsB57A2r7Wlc1UFcTR9IzrPvuNVO4B8LGqF8qcpsVOhJCA==", + "version": "8.14.2", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.14.2.tgz", + "integrity": "sha512-wEBG1ftX4jcglPxgFCMJmZ2PLtSbJ2Peg6TmpJFTbe9GZYOQCDPdMYu/Tm0/bGZkw8paZnJY45J4K2PZrLYq8g==", "engines": { "node": ">=10.0.0" }, "peerDependencies": { "bufferutil": "^4.0.1", - "utf-8-validate": "^5.0.2" + "utf-8-validate": ">=5.0.2" }, "peerDependenciesMeta": { "bufferutil": { @@ -13021,11 +13401,12 @@ } }, "node_modules/webpack-merge": { - "version": "5.8.0", - "resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.8.0.tgz", - "integrity": "sha512-/SaI7xY0831XwP6kzuwhKWVKDP9t1QY1h65lAFLbZqMPIuYcD9QAW4u9STIbU9kaJbPBB/geU/gLr1wDjOhQ+Q==", + "version": "5.10.0", + "resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.10.0.tgz", + "integrity": "sha512-+4zXKdx7UnO+1jaN4l2lHVD+mFvnlZQP/6ljaJVb4SZiwIKeUnrT5l0gkT8z+n4hKpC+jpOv6O9R+gLtag7pSA==", "dependencies": { "clone-deep": "^4.0.1", + "flat": "^5.0.2", "wildcard": "^2.0.0" }, "engines": { @@ -13041,9 +13422,9 @@ } }, "node_modules/webpack/node_modules/acorn": { - "version": "8.7.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz", - "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==", + "version": "8.12.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz", + "integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==", "bin": { "acorn": "bin/acorn" }, @@ -13051,10 +13432,10 @@ "node": ">=0.4.0" } }, - "node_modules/webpack/node_modules/acorn-import-assertions": { - "version": "1.8.0", - "resolved": "https://registry.npmjs.org/acorn-import-assertions/-/acorn-import-assertions-1.8.0.tgz", - "integrity": "sha512-m7VZ3jwz4eK6A4Vtt8Ew1/mNbP24u0FhdyfA7fSvnJR6LMdfOYnmuIrrJAgrYfYJ10F/otaHTtrtrtmHdMNzEw==", + "node_modules/webpack/node_modules/acorn-import-attributes": { + "version": "1.9.5", + "resolved": "https://registry.npmjs.org/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz", + "integrity": "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==", "peerDependencies": { "acorn": "^8" } @@ -13079,9 +13460,9 @@ } }, "node_modules/webpack/node_modules/schema-utils": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.1.1.tgz", - "integrity": "sha512-Y5PQxS4ITlC+EahLuXaY86TXfR7Dc5lw294alXOq86JAHCihAIZfqv8nNCWvaEJvaC51uN9hbLGeV0cFBdH+Fw==", + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz", + "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==", "dependencies": { "@types/json-schema": "^7.0.8", "ajv": "^6.12.5", @@ -13176,9 +13557,9 @@ "integrity": "sha512-JcKqAHLPxcdb9KM49dufGXn2x3ssnfjbcaQdLlfZsL9rH9wgDQjUtDxbo8NE0F6SFvydeu1VhZe7hZuHsB2/pw==" }, "node_modules/wrap-ansi": { - "version": "8.0.1", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.0.1.tgz", - "integrity": "sha512-QFF+ufAqhoYHvoHdajT/Po7KoXVBPXS2bgjIam5isfWJPfIOnQZ50JtUiVvCv/sjgacf3yRrt2ZKUZ/V4itN4g==", + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", @@ -13326,95 +13707,105 @@ }, "dependencies": { "@algolia/autocomplete-core": { - "version": "1.7.1", - "resolved": "https://registry.npmjs.org/@algolia/autocomplete-core/-/autocomplete-core-1.7.1.tgz", - "integrity": "sha512-eiZw+fxMzNQn01S8dA/hcCpoWCOCwcIIEUtHHdzN5TGB3IpzLbuhqFeTfh2OUhhgkE8Uo17+wH+QJ/wYyQmmzg==", + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-core/-/autocomplete-core-1.9.3.tgz", + "integrity": "sha512-009HdfugtGCdC4JdXUbVJClA0q0zh24yyePn+KUGk3rP7j8FEe/m5Yo/z65gn6nP/cM39PxpzqKrL7A6fP6PPw==", + "requires": { + "@algolia/autocomplete-plugin-algolia-insights": "1.9.3", + "@algolia/autocomplete-shared": "1.9.3" + } + }, + "@algolia/autocomplete-plugin-algolia-insights": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.9.3.tgz", + "integrity": "sha512-a/yTUkcO/Vyy+JffmAnTWbr4/90cLzw+CC3bRbhnULr/EM0fGNvM13oQQ14f2moLMcVDyAx/leczLlAOovhSZg==", "requires": { - "@algolia/autocomplete-shared": "1.7.1" + "@algolia/autocomplete-shared": "1.9.3" } }, "@algolia/autocomplete-preset-algolia": { - "version": "1.7.1", - "resolved": "https://registry.npmjs.org/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.7.1.tgz", - "integrity": "sha512-pJwmIxeJCymU1M6cGujnaIYcY3QPOVYZOXhFkWVM7IxKzy272BwCvMFMyc5NpG/QmiObBxjo7myd060OeTNJXg==", + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.9.3.tgz", + "integrity": "sha512-d4qlt6YmrLMYy95n5TB52wtNDr6EgAIPH81dvvvW8UmuWRgxEtY0NJiPwl/h95JtG2vmRM804M0DSwMCNZlzRA==", "requires": { - "@algolia/autocomplete-shared": "1.7.1" + "@algolia/autocomplete-shared": "1.9.3" } }, "@algolia/autocomplete-shared": { - "version": "1.7.1", - "resolved": "https://registry.npmjs.org/@algolia/autocomplete-shared/-/autocomplete-shared-1.7.1.tgz", - "integrity": "sha512-eTmGVqY3GeyBTT8IWiB2K5EuURAqhnumfktAEoHxfDY2o7vg2rSnO16ZtIG0fMgt3py28Vwgq42/bVEuaQV7pg==" + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-shared/-/autocomplete-shared-1.9.3.tgz", + "integrity": "sha512-Wnm9E4Ye6Rl6sTTqjoymD+l8DjSTHsHboVRYrKgEt8Q7UHm9nYbqhN/i0fhUYA3OAEH7WA8x3jfpnmJm3rKvaQ==", + "requires": {} }, "@algolia/cache-browser-local-storage": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/cache-browser-local-storage/-/cache-browser-local-storage-4.14.0.tgz", - "integrity": "sha512-vSX0uPTgTuWdKOv0DbjFBl5AGlWDzYADtv5ChLBBKHTBhAKp4f9b38zDB0v89pCbcoAGZjtb6UTM+pUEVSTuSw==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/cache-browser-local-storage/-/cache-browser-local-storage-4.23.3.tgz", + "integrity": "sha512-vRHXYCpPlTDE7i6UOy2xE03zHF2C8MEFjPN2v7fRbqVpcOvAUQK81x3Kc21xyb5aSIpYCjWCZbYZuz8Glyzyyg==", "requires": { - "@algolia/cache-common": "4.14.0" + "@algolia/cache-common": "4.23.3" } }, "@algolia/cache-common": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/cache-common/-/cache-common-4.14.0.tgz", - "integrity": "sha512-9bCWX78td6DEtyVIJc2R8MokniFFgbS5r9ADVvBuBeDtVuNhOwDO/MYZ2WlAQJTwos9TtS9v0iJ9Ym0rDHMldA==" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/cache-common/-/cache-common-4.23.3.tgz", + "integrity": "sha512-h9XcNI6lxYStaw32pHpB1TMm0RuxphF+Ik4o7tcQiodEdpKK+wKufY6QXtba7t3k8eseirEMVB83uFFF3Nu54A==" }, "@algolia/cache-in-memory": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/cache-in-memory/-/cache-in-memory-4.14.0.tgz", - "integrity": "sha512-kIH9JjebSsZVxnTjaWarunFkWaHnMZ5vG98KwvQj++I4PCMgk7z/GBm9bMNgPUsDPqHxQ0p9HO/j8YgN6VYxgQ==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/cache-in-memory/-/cache-in-memory-4.23.3.tgz", + "integrity": "sha512-yvpbuUXg/+0rbcagxNT7un0eo3czx2Uf0y4eiR4z4SD7SiptwYTpbuS0IHxcLHG3lq22ukx1T6Kjtk/rT+mqNg==", "requires": { - "@algolia/cache-common": "4.14.0" + "@algolia/cache-common": "4.23.3" } }, "@algolia/client-account": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/client-account/-/client-account-4.14.0.tgz", - "integrity": "sha512-b0rAB3D2rf5qOeBZbUNcixl9EmiVPz6QgEvP2TC3Ed85+8xdVhtbyLD5EzTHQr2BPXvklo5NK1K5Q3UOZ9ojJQ==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-account/-/client-account-4.23.3.tgz", + "integrity": "sha512-hpa6S5d7iQmretHHF40QGq6hz0anWEHGlULcTIT9tbUssWUriN9AUXIFQ8Ei4w9azD0hc1rUok9/DeQQobhQMA==", "requires": { - "@algolia/client-common": "4.14.0", - "@algolia/client-search": "4.14.0", - "@algolia/transporter": "4.14.0" + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "@algolia/client-analytics": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-4.14.0.tgz", - "integrity": "sha512-HcuAbUP2D2SZiV8pvBd6ZoJNJ1Zu5bvUctCknGS7QVQv4xfeDHFcQulwEPftKBhIoJmVZPsQznpeLf+PTGTA+w==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-4.23.3.tgz", + "integrity": "sha512-LBsEARGS9cj8VkTAVEZphjxTjMVCci+zIIiRhpFun9jGDUlS1XmhCW7CTrnaWeIuCQS/2iPyRqSy1nXPjcBLRA==", "requires": { - "@algolia/client-common": "4.14.0", - "@algolia/client-search": "4.14.0", - "@algolia/requester-common": "4.14.0", - "@algolia/transporter": "4.14.0" + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "@algolia/client-common": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.14.0.tgz", - "integrity": "sha512-7pmtPOicY6QEBQEYinChkVVi0SnDGcgJn1P0GkWxIMD23ZQk7o0/eMAQYqkGR3TET6YB/bZDeDrpL5v4DKN3tg==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.23.3.tgz", + "integrity": "sha512-l6EiPxdAlg8CYhroqS5ybfIczsGUIAC47slLPOMDeKSVXYG1n0qGiz4RjAHLw2aD0xzh2EXZ7aRguPfz7UKDKw==", "requires": { - "@algolia/requester-common": "4.14.0", - "@algolia/transporter": "4.14.0" + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "@algolia/client-personalization": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-4.14.0.tgz", - "integrity": "sha512-O/vADaSZYAzL0o8L+2QeTZr1O3VXu8DjBUXnEWWgn96v6zqTH0aoQsQ7gvYEsGNvTGiZZwNJNruzMaBNG0GNUA==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-4.23.3.tgz", + "integrity": "sha512-3E3yF3Ocr1tB/xOZiuC3doHQBQ2zu2MPTYZ0d4lpfWads2WTKG7ZzmGnsHmm63RflvDeLK/UVx7j2b3QuwKQ2g==", "requires": { - "@algolia/client-common": "4.14.0", - "@algolia/requester-common": "4.14.0", - "@algolia/transporter": "4.14.0" + "@algolia/client-common": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "@algolia/client-search": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.14.0.tgz", - "integrity": "sha512-gFxteVMUzEMq6lDEex/gZKNudrFmOFLuWS9SQCU+sXeTCRw32aY5/RBDigOkD6Yp6nLkfnYWvPnDshwY6WgTbw==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.23.3.tgz", + "integrity": "sha512-P4VAKFHqU0wx9O+q29Q8YVuaowaZ5EM77rxfmGnkHUJggh28useXQdopokgwMeYw2XUht49WX5RcTQ40rZIabw==", "requires": { - "@algolia/client-common": "4.14.0", - "@algolia/requester-common": "4.14.0", - "@algolia/transporter": "4.14.0" + "@algolia/client-common": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "@algolia/events": { @@ -13423,47 +13814,65 @@ "integrity": "sha512-FQzvOCgoFXAbf5Y6mYozw2aj5KCJoA3m4heImceldzPSMbdyS4atVjJzXKMsfX3wnZTFYwkkt8/z8UesLHlSBQ==" }, "@algolia/logger-common": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/logger-common/-/logger-common-4.14.0.tgz", - "integrity": "sha512-1Fw+5Nd4d7NWNA9FhOIIXzESJn+j5VTO/f3YK+XhoOlbAwfMbD32InWEjNglrcHnSO8kpqrizFXveKTx1CzoKw==" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/logger-common/-/logger-common-4.23.3.tgz", + "integrity": "sha512-y9kBtmJwiZ9ZZ+1Ek66P0M68mHQzKRxkW5kAAXYN/rdzgDN0d2COsViEFufxJ0pb45K4FRcfC7+33YB4BLrZ+g==" }, "@algolia/logger-console": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/logger-console/-/logger-console-4.14.0.tgz", - "integrity": "sha512-nBJwg1TVdzAZCIA5tIFYKA+QqYGD9iRhO8yEdm68VcOeckyNTQuvJtAkWyvzr2qNL6GD+bN8nUQ8Cf5HFy/wZg==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/logger-console/-/logger-console-4.23.3.tgz", + "integrity": "sha512-8xoiseoWDKuCVnWP8jHthgaeobDLolh00KJAdMe9XPrWPuf1by732jSpgy2BlsLTaT9m32pHI8CRfrOqQzHv3A==", + "requires": { + "@algolia/logger-common": "4.23.3" + } + }, + "@algolia/recommend": { + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-4.23.3.tgz", + "integrity": "sha512-9fK4nXZF0bFkdcLBRDexsnGzVmu4TSYZqxdpgBW2tEyfuSSY54D4qSRkLmNkrrz4YFvdh2GM1gA8vSsnZPR73w==", "requires": { - "@algolia/logger-common": "4.14.0" + "@algolia/cache-browser-local-storage": "4.23.3", + "@algolia/cache-common": "4.23.3", + "@algolia/cache-in-memory": "4.23.3", + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/logger-console": "4.23.3", + "@algolia/requester-browser-xhr": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/requester-node-http": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "@algolia/requester-browser-xhr": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-4.14.0.tgz", - "integrity": "sha512-J4ND/l0/wOyztyOA3F4kFNIj/QDTeiS45m3hqSCVXpIJn/iq1ZP8zYW5q0/2sEMehO8TawVJiHnXYV0kO0Dk0Q==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-4.23.3.tgz", + "integrity": "sha512-jDWGIQ96BhXbmONAQsasIpTYWslyjkiGu0Quydjlowe+ciqySpiDUrJHERIRfELE5+wFc7hc1Q5hqjGoV7yghw==", "requires": { - "@algolia/requester-common": "4.14.0" + "@algolia/requester-common": "4.23.3" } }, "@algolia/requester-common": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/requester-common/-/requester-common-4.14.0.tgz", - "integrity": "sha512-8DGIW5keIbAFet2TKGr/C9DVJ1r8IWFjgf4URPHn6NHMf6R+ruQp0gOf7xBP1Bw6JIS3/DbvlGqbw8sNO/N+Hw==" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/requester-common/-/requester-common-4.23.3.tgz", + "integrity": "sha512-xloIdr/bedtYEGcXCiF2muajyvRhwop4cMZo+K2qzNht0CMzlRkm8YsDdj5IaBhshqfgmBb3rTg4sL4/PpvLYw==" }, "@algolia/requester-node-http": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-4.14.0.tgz", - "integrity": "sha512-DP0k1H9c6+lR4G/jKG4kez3QW1ksUDSSSSy3I8nhPZErIGgd0IqCTXDt1GwykDEkvYj/l4sA3x8pJtDMW3JSzw==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-4.23.3.tgz", + "integrity": "sha512-zgu++8Uj03IWDEJM3fuNl34s746JnZOWn1Uz5taV1dFyJhVM/kTNw9Ik7YJWiUNHJQXcaD8IXD1eCb0nq/aByA==", "requires": { - "@algolia/requester-common": "4.14.0" + "@algolia/requester-common": "4.23.3" } }, "@algolia/transporter": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/@algolia/transporter/-/transporter-4.14.0.tgz", - "integrity": "sha512-AP+8Qxeg0XvQ3rFbj4pIUzDMmtjo5pgBMx/57ADbge5Y4Y9ByDdQNjEKk6QFIe70SAwR/cGzglwYg7nl8mK/OA==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/transporter/-/transporter-4.23.3.tgz", + "integrity": "sha512-Wjl5gttqnf/gQKJA+dafnD0Y6Yw97yvfY8R9h0dQltX1GXTgNs1zWgvtWW0tHl1EgMdhAyw189uWiZMnL3QebQ==", "requires": { - "@algolia/cache-common": "4.14.0", - "@algolia/logger-common": "4.14.0", - "@algolia/requester-common": "4.14.0" + "@algolia/cache-common": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/requester-common": "4.23.3" } }, "@ampproject/remapping": { @@ -13476,54 +13885,107 @@ } }, "@babel/code-frame": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", - "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==", + "version": "7.22.13", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.13.tgz", + "integrity": "sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==", "requires": { - "@babel/highlight": "^7.18.6" + "@babel/highlight": "^7.22.13", + "chalk": "^2.4.2" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "requires": { + "color-name": "1.1.3" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==" + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==" + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==" + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "requires": { + "has-flag": "^3.0.0" + } + } } }, "@babel/compat-data": { - "version": "7.18.8", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.18.8.tgz", - "integrity": "sha512-HSmX4WZPPK3FUxYp7g2T6EyO8j96HlZJlxmKPSh6KAcqwyDrfx7hKjXpAW/0FhFfTJsR0Yt4lAjLI2coMptIHQ==" + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.23.3.tgz", + "integrity": "sha512-BmR4bWbDIoFJmJ9z2cZ8Gmm2MXgEDgjdWgpKmKWUt54UGFJdlj31ECtbaDvCG/qVdG3AQ1SfpZEs01lUFbzLOQ==" }, "@babel/core": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.18.9.tgz", - "integrity": "sha512-1LIb1eL8APMy91/IMW+31ckrfBM4yCoLaVzoDhZUKSM4cu1L1nIidyxkCgzPAgrC5WEz36IPEr/eSeSF9pIn+g==", - "requires": { - "@ampproject/remapping": "^2.1.0", - "@babel/code-frame": "^7.18.6", - "@babel/generator": "^7.18.9", - "@babel/helper-compilation-targets": "^7.18.9", - "@babel/helper-module-transforms": "^7.18.9", - "@babel/helpers": "^7.18.9", - "@babel/parser": "^7.18.9", - "@babel/template": "^7.18.6", - "@babel/traverse": "^7.18.9", - "@babel/types": "^7.18.9", - "convert-source-map": "^1.7.0", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.23.3.tgz", + "integrity": "sha512-Jg+msLuNuCJDyBvFv5+OKOUjWMZgd85bKjbICd3zWrKAo+bJ49HJufi7CQE0q0uR8NGyO6xkCACScNqyjHSZew==", + "requires": { + "@ampproject/remapping": "^2.2.0", + "@babel/code-frame": "^7.22.13", + "@babel/generator": "^7.23.3", + "@babel/helper-compilation-targets": "^7.22.15", + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helpers": "^7.23.2", + "@babel/parser": "^7.23.3", + "@babel/template": "^7.22.15", + "@babel/traverse": "^7.23.3", + "@babel/types": "^7.23.3", + "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", - "json5": "^2.2.1", - "semver": "^6.3.0" + "json5": "^2.2.3", + "semver": "^6.3.1" }, "dependencies": { "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==" } } }, "@babel/generator": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.18.9.tgz", - "integrity": "sha512-wt5Naw6lJrL1/SGkipMiFxJjtyczUWTP38deiP1PO60HsBjDeKk08CGC3S8iVuvf0FmTdgKwU1KIXzSKL1G0Ug==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.23.3.tgz", + "integrity": "sha512-keeZWAV4LU3tW0qRi19HRpabC/ilM0HRBBzf9/k8FFiG4KVpiv0FIy4hHfLfFQZNhziCTPTmd59zoyv6DNISzg==", "requires": { - "@babel/types": "^7.18.9", + "@babel/types": "^7.23.3", "@jridgewell/gen-mapping": "^0.3.2", + "@jridgewell/trace-mapping": "^0.3.17", "jsesc": "^2.5.1" }, "dependencies": { @@ -13540,244 +14002,254 @@ } }, "@babel/helper-annotate-as-pure": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.18.6.tgz", - "integrity": "sha512-duORpUiYrEpzKIop6iNbjnwKLAKnJ47csTyRACyEmWj0QdUrm5aqNJGHSSEQSUAvNW0ojX0dOmK9dZduvkfeXA==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.22.5.tgz", + "integrity": "sha512-LvBTxu8bQSQkcyKOU+a1btnNFQ1dMAd0R6PyW3arXes06F6QLWLIrd681bxRPIXlrMGR3XYnW9JyML7dP3qgxg==", "requires": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.5" } }, "@babel/helper-builder-binary-assignment-operator-visitor": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.18.9.tgz", - "integrity": "sha512-yFQ0YCHoIqarl8BCRwBL8ulYUaZpz3bNsA7oFepAzee+8/+ImtADXNOmO5vJvsPff3qi+hvpkY/NYBTrBQgdNw==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.22.15.tgz", + "integrity": "sha512-QkBXwGgaoC2GtGZRoma6kv7Szfv06khvhFav67ZExau2RaXzy8MpHSMO2PNoP2XtmQphJQRHFfg77Bq731Yizw==", "requires": { - "@babel/helper-explode-assignable-expression": "^7.18.6", - "@babel/types": "^7.18.9" + "@babel/types": "^7.22.15" } }, "@babel/helper-compilation-targets": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.18.9.tgz", - "integrity": "sha512-tzLCyVmqUiFlcFoAPLA/gL9TeYrF61VLNtb+hvkuVaB5SUjW7jcfrglBIX1vUIoT7CLP3bBlIMeyEsIl2eFQNg==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.22.15.tgz", + "integrity": "sha512-y6EEzULok0Qvz8yyLkCvVX+02ic+By2UdOhylwUOvOn9dvYc9mKICJuuU1n1XBI02YWsNsnrY1kc6DVbjcXbtw==", "requires": { - "@babel/compat-data": "^7.18.8", - "@babel/helper-validator-option": "^7.18.6", - "browserslist": "^4.20.2", - "semver": "^6.3.0" + "@babel/compat-data": "^7.22.9", + "@babel/helper-validator-option": "^7.22.15", + "browserslist": "^4.21.9", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" }, "dependencies": { + "lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "requires": { + "yallist": "^3.0.2" + } + }, "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==" + }, + "yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==" } } }, "@babel/helper-create-class-features-plugin": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.18.9.tgz", - "integrity": "sha512-WvypNAYaVh23QcjpMR24CwZY2Nz6hqdOcFdPbNpV56hL5H6KiFheO7Xm1aPdlLQ7d5emYZX7VZwPp9x3z+2opw==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.22.15.tgz", + "integrity": "sha512-jKkwA59IXcvSaiK2UN45kKwSC9o+KuoXsBDvHvU/7BecYIp8GQ2UwrVvFgJASUT+hBnwJx6MhvMCuMzwZZ7jlg==", "requires": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-function-name": "^7.18.9", - "@babel/helper-member-expression-to-functions": "^7.18.9", - "@babel/helper-optimise-call-expression": "^7.18.6", - "@babel/helper-replace-supers": "^7.18.9", - "@babel/helper-split-export-declaration": "^7.18.6" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-environment-visitor": "^7.22.5", + "@babel/helper-function-name": "^7.22.5", + "@babel/helper-member-expression-to-functions": "^7.22.15", + "@babel/helper-optimise-call-expression": "^7.22.5", + "@babel/helper-replace-supers": "^7.22.9", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.6", + "semver": "^6.3.1" + }, + "dependencies": { + "semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==" + } } }, "@babel/helper-create-regexp-features-plugin": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.18.6.tgz", - "integrity": "sha512-7LcpH1wnQLGrI+4v+nPp+zUvIkF9x0ddv1Hkdue10tg3gmRnLy97DXh4STiOf1qeIInyD69Qv5kKSZzKD8B/7A==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.22.15.tgz", + "integrity": "sha512-29FkPLFjn4TPEa3RE7GpW+qbE8tlsu3jntNYNfcGsc49LphF1PQIiD+vMZ1z1xVOKt+93khA9tc2JBs3kBjA7w==", "requires": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "regexpu-core": "^5.1.0" - } - }, - "@babel/helper-define-polyfill-provider": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.3.1.tgz", - "integrity": "sha512-J9hGMpJQmtWmj46B3kBHmL38UhJGhYX7eqkcq+2gsstyYt341HmPeWspihX43yVRA0mS+8GGk2Gckc7bY/HCmA==", - "requires": { - "@babel/helper-compilation-targets": "^7.13.0", - "@babel/helper-module-imports": "^7.12.13", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/traverse": "^7.13.0", - "debug": "^4.1.1", - "lodash.debounce": "^4.0.8", - "resolve": "^1.14.2", - "semver": "^6.1.2" + "@babel/helper-annotate-as-pure": "^7.22.5", + "regexpu-core": "^5.3.1", + "semver": "^6.3.1" }, "dependencies": { "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==" } } }, - "@babel/helper-environment-visitor": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz", - "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==" - }, - "@babel/helper-explode-assignable-expression": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.18.6.tgz", - "integrity": "sha512-eyAYAsQmB80jNfg4baAtLeWAQHfHFiR483rzFK+BhETlGZaQC9bsfrugfXDCbRHLQbIA7U5NxhhOxN7p/dWIcg==", + "@babel/helper-define-polyfill-provider": { + "version": "0.4.3", + "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.4.3.tgz", + "integrity": "sha512-WBrLmuPP47n7PNwsZ57pqam6G/RGo1vw/87b0Blc53tZNGZ4x7YvZ6HgQe2vo1W/FR20OgjeZuGXzudPiXHFug==", "requires": { - "@babel/types": "^7.18.6" + "@babel/helper-compilation-targets": "^7.22.6", + "@babel/helper-plugin-utils": "^7.22.5", + "debug": "^4.1.1", + "lodash.debounce": "^4.0.8", + "resolve": "^1.14.2" } }, + "@babel/helper-environment-visitor": { + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.20.tgz", + "integrity": "sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==" + }, "@babel/helper-function-name": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.18.9.tgz", - "integrity": "sha512-fJgWlZt7nxGksJS9a0XdSaI4XvpExnNIgRP+rVefWh5U7BL8pPuir6SJUmFKRfjWQ51OtWSzwOxhaH/EBWWc0A==", + "version": "7.23.0", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.23.0.tgz", + "integrity": "sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==", "requires": { - "@babel/template": "^7.18.6", - "@babel/types": "^7.18.9" + "@babel/template": "^7.22.15", + "@babel/types": "^7.23.0" } }, "@babel/helper-hoist-variables": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz", - "integrity": "sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz", + "integrity": "sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==", "requires": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.5" } }, "@babel/helper-member-expression-to-functions": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.18.9.tgz", - "integrity": "sha512-RxifAh2ZoVU67PyKIO4AMi1wTenGfMR/O/ae0CCRqwgBAt5v7xjdtRw7UoSbsreKrQn5t7r89eruK/9JjYHuDg==", + "version": "7.23.0", + "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.23.0.tgz", + "integrity": "sha512-6gfrPwh7OuT6gZyJZvd6WbTfrqAo7vm4xCzAXOusKqq/vWdKXphTpj5klHKNmRUU6/QRGlBsyU9mAIPaWHlqJA==", "requires": { - "@babel/types": "^7.18.9" + "@babel/types": "^7.23.0" } }, "@babel/helper-module-imports": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz", - "integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.22.15.tgz", + "integrity": "sha512-0pYVBnDKZO2fnSPCrgM/6WMc7eS20Fbok+0r88fp+YtWVLZrp4CkafFGIp+W0VKw4a22sgebPT99y+FDNMdP4w==", "requires": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.15" } }, "@babel/helper-module-transforms": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.18.9.tgz", - "integrity": "sha512-KYNqY0ICwfv19b31XzvmI/mfcylOzbLtowkw+mfvGPAQ3kfCnMLYbED3YecL5tPd8nAYFQFAd6JHp2LxZk/J1g==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.23.3.tgz", + "integrity": "sha512-7bBs4ED9OmswdfDzpz4MpWgSrV7FXlc3zIagvLFjS5H+Mk7Snr21vQ6QwrsoCGMfNC4e4LQPdoULEt4ykz0SRQ==", "requires": { - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-module-imports": "^7.18.6", - "@babel/helper-simple-access": "^7.18.6", - "@babel/helper-split-export-declaration": "^7.18.6", - "@babel/helper-validator-identifier": "^7.18.6", - "@babel/template": "^7.18.6", - "@babel/traverse": "^7.18.9", - "@babel/types": "^7.18.9" + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-simple-access": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.6", + "@babel/helper-validator-identifier": "^7.22.20" } }, "@babel/helper-optimise-call-expression": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.18.6.tgz", - "integrity": "sha512-HP59oD9/fEHQkdcbgFCnbmgH5vIQTJbxh2yf+CdM89/glUNnuzr87Q8GIjGEnOktTROemO0Pe0iPAYbqZuOUiA==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.22.5.tgz", + "integrity": "sha512-HBwaojN0xFRx4yIvpwGqxiV2tUfl7401jlok564NgB9EHS1y6QT17FmKWm4ztqjeVdXLuC4fSvHc5ePpQjoTbw==", "requires": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.5" } }, "@babel/helper-plugin-utils": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.18.9.tgz", - "integrity": "sha512-aBXPT3bmtLryXaoJLyYPXPlSD4p1ld9aYeR+sJNOZjJJGiOpb+fKfh3NkcCu7J54nUJwCERPBExCCpyCOHnu/w==" + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz", + "integrity": "sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==" }, "@babel/helper-remap-async-to-generator": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.18.9.tgz", - "integrity": "sha512-dI7q50YKd8BAv3VEfgg7PS7yD3Rtbi2J1XMXaalXO0W0164hYLnh8zpjRS0mte9MfVp/tltvr/cfdXPvJr1opA==", + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.22.20.tgz", + "integrity": "sha512-pBGyV4uBqOns+0UvhsTO8qgl8hO89PmiDYv+/COyp1aeMcmfrfruz+/nCMFiYyFF/Knn0yfrC85ZzNFjembFTw==", "requires": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-wrap-function": "^7.18.9", - "@babel/types": "^7.18.9" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-wrap-function": "^7.22.20" } }, "@babel/helper-replace-supers": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.18.9.tgz", - "integrity": "sha512-dNsWibVI4lNT6HiuOIBr1oyxo40HvIVmbwPUm3XZ7wMh4k2WxrxTqZwSqw/eEmXDS9np0ey5M2bz9tBmO9c+YQ==", + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.22.20.tgz", + "integrity": "sha512-qsW0In3dbwQUbK8kejJ4R7IHVGwHJlV6lpG6UA7a9hSa2YEiAib+N1T2kr6PEeUT+Fl7najmSOS6SmAwCHK6Tw==", "requires": { - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-member-expression-to-functions": "^7.18.9", - "@babel/helper-optimise-call-expression": "^7.18.6", - "@babel/traverse": "^7.18.9", - "@babel/types": "^7.18.9" + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-member-expression-to-functions": "^7.22.15", + "@babel/helper-optimise-call-expression": "^7.22.5" } }, "@babel/helper-simple-access": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.18.6.tgz", - "integrity": "sha512-iNpIgTgyAvDQpDj76POqg+YEt8fPxx3yaNBg3S30dxNKm2SWfYhD0TGrK/Eu9wHpUW63VQU894TsTg+GLbUa1g==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.22.5.tgz", + "integrity": "sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==", "requires": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.5" } }, "@babel/helper-skip-transparent-expression-wrappers": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.18.9.tgz", - "integrity": "sha512-imytd2gHi3cJPsybLRbmFrF7u5BIEuI2cNheyKi3/iOBC63kNn3q8Crn2xVuESli0aM4KYsyEqKyS7lFL8YVtw==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.22.5.tgz", + "integrity": "sha512-tK14r66JZKiC43p8Ki33yLBVJKlQDFoA8GYN67lWCDCqoL6EMMSuM9b+Iff2jHaM/RRFYl7K+iiru7hbRqNx8Q==", "requires": { - "@babel/types": "^7.18.9" + "@babel/types": "^7.22.5" } }, "@babel/helper-split-export-declaration": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz", - "integrity": "sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==", + "version": "7.22.6", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz", + "integrity": "sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==", "requires": { - "@babel/types": "^7.18.6" + "@babel/types": "^7.22.5" } }, + "@babel/helper-string-parser": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz", + "integrity": "sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==" + }, "@babel/helper-validator-identifier": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.18.6.tgz", - "integrity": "sha512-MmetCkz9ej86nJQV+sFCxoGGrUbU3q02kgLciwkrt9QqEB7cP39oKEY0PakknEO0Gu20SskMRi+AYZ3b1TpN9g==" + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz", + "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==" }, "@babel/helper-validator-option": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.18.6.tgz", - "integrity": "sha512-XO7gESt5ouv/LRJdrVjkShckw6STTaB7l9BrpBaAHDeF5YZT+01PCwmR0SJHnkW6i8OwW/EVWRShfi4j2x+KQw==" + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.22.15.tgz", + "integrity": "sha512-bMn7RmyFjY/mdECUbgn9eoSY4vqvacUnS9i9vGAGttgFWesO6B4CYWA7XlpbWgBt71iv/hfbPlynohStqnu5hA==" }, "@babel/helper-wrap-function": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.18.9.tgz", - "integrity": "sha512-cG2ru3TRAL6a60tfQflpEfs4ldiPwF6YW3zfJiRgmoFVIaC1vGnBBgatfec+ZUziPHkHSaXAuEck3Cdkf3eRpQ==", + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.22.20.tgz", + "integrity": "sha512-pms/UwkOpnQe/PDAEdV/d7dVCoBbB+R4FvYoHGZz+4VPcg7RtYy2KP7S2lbuWM6FCSgob5wshfGESbC/hzNXZw==", "requires": { - "@babel/helper-function-name": "^7.18.9", - "@babel/template": "^7.18.6", - "@babel/traverse": "^7.18.9", - "@babel/types": "^7.18.9" + "@babel/helper-function-name": "^7.22.5", + "@babel/template": "^7.22.15", + "@babel/types": "^7.22.19" } }, "@babel/helpers": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.18.9.tgz", - "integrity": "sha512-Jf5a+rbrLoR4eNdUmnFu8cN5eNJT6qdTdOg5IHIzq87WwyRw9PwguLFOWYgktN/60IP4fgDUawJvs7PjQIzELQ==", + "version": "7.23.2", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.23.2.tgz", + "integrity": "sha512-lzchcp8SjTSVe/fPmLwtWVBFC7+Tbn8LGHDVfDp9JGxpAY5opSaEFgt8UQvrnECWOTdji2mOWMz1rOhkHscmGQ==", "requires": { - "@babel/template": "^7.18.6", - "@babel/traverse": "^7.18.9", - "@babel/types": "^7.18.9" + "@babel/template": "^7.22.15", + "@babel/traverse": "^7.23.2", + "@babel/types": "^7.23.0" } }, "@babel/highlight": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz", - "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==", + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.22.20.tgz", + "integrity": "sha512-dkdMCN3py0+ksCgYmGG8jKeGA/8Tk+gJwSYYlFGxG5lmhfKNoAy004YpLxpS1W2J8m/EK2Ew+yOs9pVRwO89mg==", "requires": { - "@babel/helper-validator-identifier": "^7.18.6", - "chalk": "^2.0.0", + "@babel/helper-validator-identifier": "^7.22.20", + "chalk": "^2.4.2", "js-tokens": "^4.0.0" }, "dependencies": { @@ -13833,171 +14305,52 @@ } }, "@babel/parser": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.18.9.tgz", - "integrity": "sha512-9uJveS9eY9DJ0t64YbIBZICtJy8a5QrDEVdiLCG97fVLpDTpGX7t8mMSb6OWw6Lrnjqj4O8zwjELX3dhoMgiBg==" + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.23.3.tgz", + "integrity": "sha512-uVsWNvlVsIninV2prNz/3lHCb+5CJ+e+IUBfbjToAHODtfGYLfCFuY4AU7TskI+dAKk+njsPiBjq1gKTvZOBaw==" }, "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.18.6.tgz", - "integrity": "sha512-Dgxsyg54Fx1d4Nge8UnvTrED63vrwOdPmyvPzlNN/boaliRP54pm3pGzZD1SJUwrBA+Cs/xdG8kXX6Mn/RfISQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.23.3.tgz", + "integrity": "sha512-iRkKcCqb7iGnq9+3G6rZ+Ciz5VywC4XNRHe57lKM+jOeYAoR0lVqdeeDRfh0tQcTfw/+vBhHn926FmQhLtlFLQ==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.18.9.tgz", - "integrity": "sha512-AHrP9jadvH7qlOj6PINbgSuphjQUAK7AOT7DPjBo9EHoLhQTnnK5u45e1Hd4DbSQEO9nqPWtQ89r+XEOWFScKg==", - "requires": { - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-skip-transparent-expression-wrappers": "^7.18.9", - "@babel/plugin-proposal-optional-chaining": "^7.18.9" - } - }, - "@babel/plugin-proposal-async-generator-functions": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.18.6.tgz", - "integrity": "sha512-WAz4R9bvozx4qwf74M+sfqPMKfSqwM0phxPTR6iJIi8robgzXwkEgmeJG1gEKhm6sDqT/U9aV3lfcqybIpev8w==", - "requires": { - "@babel/helper-environment-visitor": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-remap-async-to-generator": "^7.18.6", - "@babel/plugin-syntax-async-generators": "^7.8.4" - } - }, - "@babel/plugin-proposal-class-properties": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.18.6.tgz", - "integrity": "sha512-cumfXOF0+nzZrrN8Rf0t7M+tF6sZc7vhQwYQck9q1/5w2OExlD+b4v4RpMJFaV1Z7WcDRgO6FqvxqxGlwo+RHQ==", - "requires": { - "@babel/helper-create-class-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" - } - }, - "@babel/plugin-proposal-class-static-block": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-static-block/-/plugin-proposal-class-static-block-7.18.6.tgz", - "integrity": "sha512-+I3oIiNxrCpup3Gi8n5IGMwj0gOCAjcJUSQEcotNnCCPMEnixawOQ+KeJPlgfjzx+FKQ1QSyZOWe7wmoJp7vhw==", - "requires": { - "@babel/helper-create-class-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-class-static-block": "^7.14.5" - } - }, - "@babel/plugin-proposal-dynamic-import": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.18.6.tgz", - "integrity": "sha512-1auuwmK+Rz13SJj36R+jqFPMJWyKEDd7lLSdOj4oJK0UTgGueSAtkrCvz9ewmgyU/P941Rv2fQwZJN8s6QruXw==", - "requires": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-dynamic-import": "^7.8.3" - } - }, - "@babel/plugin-proposal-export-namespace-from": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.18.9.tgz", - "integrity": "sha512-k1NtHyOMvlDDFeb9G5PhUXuGj8m/wiwojgQVEhJ/fsVsMCpLyOP4h0uGEjYJKrRI+EVPlb5Jk+Gt9P97lOGwtA==", - "requires": { - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/plugin-syntax-export-namespace-from": "^7.8.3" - } - }, - "@babel/plugin-proposal-json-strings": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.18.6.tgz", - "integrity": "sha512-lr1peyn9kOdbYc0xr0OdHTZ5FMqS6Di+H0Fz2I/JwMzGmzJETNeOFq2pBySw6X/KFL5EWDjlJuMsUGRFb8fQgQ==", - "requires": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-json-strings": "^7.8.3" - } - }, - "@babel/plugin-proposal-logical-assignment-operators": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.18.9.tgz", - "integrity": "sha512-128YbMpjCrP35IOExw2Fq+x55LMP42DzhOhX2aNNIdI9avSWl2PI0yuBWarr3RYpZBSPtabfadkH2yeRiMD61Q==", - "requires": { - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4" - } - }, - "@babel/plugin-proposal-nullish-coalescing-operator": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.18.6.tgz", - "integrity": "sha512-wQxQzxYeJqHcfppzBDnm1yAY0jSRkUXR2z8RePZYrKwMKgMlE8+Z6LUno+bd6LvbGh8Gltvy74+9pIYkr+XkKA==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.23.3.tgz", + "integrity": "sha512-WwlxbfMNdVEpQjZmK5mhm7oSwD3dS6eU+Iwsi4Knl9wAletWem7kaRsGOG+8UEbRyqxY4SS5zvtfXwX+jMxUwQ==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5", + "@babel/plugin-transform-optional-chaining": "^7.23.3" } }, - "@babel/plugin-proposal-numeric-separator": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.18.6.tgz", - "integrity": "sha512-ozlZFogPqoLm8WBr5Z8UckIoE4YQ5KESVcNudyXOR8uqIkliTEgJ3RoketfG6pmzLdeZF0H/wjE9/cCEitBl7Q==", + "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.23.3.tgz", + "integrity": "sha512-XaJak1qcityzrX0/IU5nKHb34VaibwP3saKqG6a/tppelgllOH13LUann4ZCIBcVOeE6H18K4Vx9QKkVww3z/w==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-numeric-separator": "^7.10.4" + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-proposal-object-rest-spread": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.18.9.tgz", - "integrity": "sha512-kDDHQ5rflIeY5xl69CEqGEZ0KY369ehsCIEbTGb4siHG5BE9sga/T0r0OUwyZNLMmZE79E1kbsqAjwFCW4ds6Q==", - "requires": { - "@babel/compat-data": "^7.18.8", - "@babel/helper-compilation-targets": "^7.18.9", - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/plugin-syntax-object-rest-spread": "^7.8.3", - "@babel/plugin-transform-parameters": "^7.18.8" - } - }, - "@babel/plugin-proposal-optional-catch-binding": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.18.6.tgz", - "integrity": "sha512-Q40HEhs9DJQyaZfUjjn6vE8Cv4GmMHCYuMGIWUnlxH6400VGxOuwWsPt4FxXxJkC/5eOzgn0z21M9gMT4MOhbw==", - "requires": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-optional-catch-binding": "^7.8.3" - } - }, - "@babel/plugin-proposal-optional-chaining": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.18.9.tgz", - "integrity": "sha512-v5nwt4IqBXihxGsW2QmCWMDS3B3bzGIk/EQVZz2ei7f3NJl8NzAJVvUmpDW5q1CRNY+Beb/k58UAH1Km1N411w==", - "requires": { - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-skip-transparent-expression-wrappers": "^7.18.9", - "@babel/plugin-syntax-optional-chaining": "^7.8.3" - } - }, - "@babel/plugin-proposal-private-methods": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.18.6.tgz", - "integrity": "sha512-nutsvktDItsNn4rpGItSNV2sz1XwS+nfU0Rg8aCx3W3NOKVzdMjJRu0O5OkgDp3ZGICSTbgRpxZoWsxoKRvbeA==", + "version": "7.12.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.12.1.tgz", + "integrity": "sha512-s6SowJIjzlhx8o7lsFx5zmY4At6CTtDvgNQDdPzkBQucle58A6b/TTeEBYtyDgmcXjUTM+vE8YOGHZzzbc/ioA==", "requires": { - "@babel/helper-create-class-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.10.4", + "@babel/plugin-syntax-object-rest-spread": "^7.8.0", + "@babel/plugin-transform-parameters": "^7.12.1" } }, "@babel/plugin-proposal-private-property-in-object": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.18.6.tgz", - "integrity": "sha512-9Rysx7FOctvT5ouj5JODjAFAkgGoudQuLPamZb0v1TGLpapdNaftzifU8NTWQm0IRjqoYypdrSmyWgkocDQ8Dw==", - "requires": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-create-class-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-private-property-in-object": "^7.14.5" - } - }, - "@babel/plugin-proposal-unicode-property-regex": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.18.6.tgz", - "integrity": "sha512-2BShG/d5yoZyXZfVePH91urL5wTG6ASZU9M4o03lKK8u8UW1y08OMttBSOADTcJrnPMpvDXRG3G8fyLh4ovs8w==", - "requires": { - "@babel/helper-create-regexp-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" - } + "version": "7.21.0-placeholder-for-preset-env.2", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz", + "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==", + "requires": {} }, "@babel/plugin-syntax-async-generators": { "version": "7.8.4", @@ -14040,11 +14393,27 @@ } }, "@babel/plugin-syntax-import-assertions": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.18.6.tgz", - "integrity": "sha512-/DU3RXad9+bZwrgWJQKbr39gYbJpLJHezqEzRzi/BHRlJ9zsQb4CK2CA/5apllXNomwA1qHwzvHl+AdEmC5krQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.23.3.tgz", + "integrity": "sha512-lPgDSU+SJLK3xmFDTV2ZRQAiM7UuUjGidwBywFavObCiZc1BeAAcMtHJKUya92hPHO+at63JJPLygilZard8jw==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-syntax-import-attributes": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.23.3.tgz", + "integrity": "sha512-pawnE0P9g10xgoP7yKr6CK63K2FMsTE+FZidZO/1PwRdzmAPVs+HS1mAURUsgaoxammTJvULUdIkEK0gOcU2tA==", + "requires": { + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-syntax-import-meta": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", + "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" } }, "@babel/plugin-syntax-json-strings": { @@ -14056,11 +14425,11 @@ } }, "@babel/plugin-syntax-jsx": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.18.6.tgz", - "integrity": "sha512-6mmljtAedFGTWu2p/8WIORGwy+61PLgOMPOdazc7YoJ9ZCWUyFy3A6CpPkRKLKD1ToAesxX8KGEViAiLo9N+7Q==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.23.3.tgz", + "integrity": "sha512-EB2MELswq55OHUoRZLGg/zC7QWUKfNLpE57m/S2yr1uEneIgsTgrSzXP3NXEsMkVn76OlaVVnzN+ugObuYGwhg==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-syntax-logical-assignment-operators": { @@ -14128,404 +14497,555 @@ } }, "@babel/plugin-syntax-typescript": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.23.3.tgz", + "integrity": "sha512-9EiNjVJOMwCO+43TqoTrgQ8jMwcAd0sWyXi9RPfIsLTj4R2MADDDQXELhffaUx/uJv2AYcxBgPwH6j4TIA4ytQ==", + "requires": { + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-syntax-unicode-sets-regex": { "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.18.6.tgz", - "integrity": "sha512-mAWAuq4rvOepWCBid55JuRNvpTNf2UGVgoz4JV0fXEKolsVZDzsa4NqCef758WZJj/GDu0gVGItjKFiClTAmZA==", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz", + "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==", "requires": { + "@babel/helper-create-regexp-features-plugin": "^7.18.6", "@babel/helper-plugin-utils": "^7.18.6" } }, "@babel/plugin-transform-arrow-functions": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.18.6.tgz", - "integrity": "sha512-9S9X9RUefzrsHZmKMbDXxweEH+YlE8JJEuat9FdvW9Qh1cw7W64jELCtWNkPBPX5En45uy28KGvA/AySqUh8CQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.23.3.tgz", + "integrity": "sha512-NzQcQrzaQPkaEwoTm4Mhyl8jI1huEL/WWIEvudjTCMJ9aBZNpsJbMASx7EQECtQQPS/DcnFpo0FIh3LvEO9cxQ==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-async-generator-functions": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.23.3.tgz", + "integrity": "sha512-59GsVNavGxAXCDDbakWSMJhajASb4kBCqDjqJsv+p5nKdbz7istmZ3HrX3L2LuiI80+zsOADCvooqQH3qGCucQ==", + "requires": { + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-remap-async-to-generator": "^7.22.20", + "@babel/plugin-syntax-async-generators": "^7.8.4" } }, "@babel/plugin-transform-async-to-generator": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.18.6.tgz", - "integrity": "sha512-ARE5wZLKnTgPW7/1ftQmSi1CmkqqHo2DNmtztFhvgtOWSDfq0Cq9/9L+KnZNYSNrydBekhW3rwShduf59RoXag==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.23.3.tgz", + "integrity": "sha512-A7LFsKi4U4fomjqXJlZg/u0ft/n8/7n7lpffUP/ZULx/DtV9SGlNKZolHH6PE8Xl1ngCc0M11OaeZptXVkfKSw==", "requires": { - "@babel/helper-module-imports": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-remap-async-to-generator": "^7.18.6" + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-remap-async-to-generator": "^7.22.20" } }, "@babel/plugin-transform-block-scoped-functions": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.18.6.tgz", - "integrity": "sha512-ExUcOqpPWnliRcPqves5HJcJOvHvIIWfuS4sroBUenPuMdmW+SMHDakmtS7qOo13sVppmUijqeTv7qqGsvURpQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.23.3.tgz", + "integrity": "sha512-vI+0sIaPIO6CNuM9Kk5VmXcMVRiOpDh7w2zZt9GXzmE/9KD70CUEVhvPR/etAeNK/FAEkhxQtXOzVF3EuRL41A==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-block-scoping": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.18.9.tgz", - "integrity": "sha512-5sDIJRV1KtQVEbt/EIBwGy4T01uYIo4KRB3VUqzkhrAIOGx7AoctL9+Ux88btY0zXdDyPJ9mW+bg+v+XEkGmtw==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.23.3.tgz", + "integrity": "sha512-QPZxHrThbQia7UdvfpaRRlq/J9ciz1J4go0k+lPBXbgaNeY7IQrBj/9ceWjvMMI07/ZBzHl/F0R/2K0qH7jCVw==", + "requires": { + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-class-properties": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.23.3.tgz", + "integrity": "sha512-uM+AN8yCIjDPccsKGlw271xjJtGii+xQIF/uMPS8H15L12jZTsLfF4o5vNO7d/oUguOyfdikHGc/yi9ge4SGIg==", + "requires": { + "@babel/helper-create-class-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-class-static-block": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.23.3.tgz", + "integrity": "sha512-PENDVxdr7ZxKPyi5Ffc0LjXdnJyrJxyqF5T5YjlVg4a0VFfQHW0r8iAtRiDXkfHlu1wwcvdtnndGYIeJLSuRMQ==", "requires": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-create-class-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-class-static-block": "^7.14.5" } }, "@babel/plugin-transform-classes": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.18.9.tgz", - "integrity": "sha512-EkRQxsxoytpTlKJmSPYrsOMjCILacAjtSVkd4gChEe2kXjFCun3yohhW5I7plXJhCemM0gKsaGMcO8tinvCA5g==", - "requires": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-function-name": "^7.18.9", - "@babel/helper-optimise-call-expression": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-replace-supers": "^7.18.9", - "@babel/helper-split-export-declaration": "^7.18.6", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.23.3.tgz", + "integrity": "sha512-FGEQmugvAEu2QtgtU0uTASXevfLMFfBeVCIIdcQhn/uBQsMTjBajdnAtanQlOcuihWh10PZ7+HWvc7NtBwP74w==", + "requires": { + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-compilation-targets": "^7.22.15", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-optimise-call-expression": "^7.22.5", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-replace-supers": "^7.22.20", + "@babel/helper-split-export-declaration": "^7.22.6", "globals": "^11.1.0" } }, "@babel/plugin-transform-computed-properties": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.18.9.tgz", - "integrity": "sha512-+i0ZU1bCDymKakLxn5srGHrsAPRELC2WIbzwjLhHW9SIE1cPYkLCL0NlnXMZaM1vhfgA2+M7hySk42VBvrkBRw==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.23.3.tgz", + "integrity": "sha512-dTj83UVTLw/+nbiHqQSFdwO9CbTtwq1DsDqm3CUEtDrZNET5rT5E6bIdTlOftDTDLMYxvxHNEYO4B9SLl8SLZw==", "requires": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/template": "^7.22.15" } }, "@babel/plugin-transform-destructuring": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.18.9.tgz", - "integrity": "sha512-p5VCYNddPLkZTq4XymQIaIfZNJwT9YsjkPOhkVEqt6QIpQFZVM9IltqqYpOEkJoN1DPznmxUDyZ5CTZs/ZCuHA==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.23.3.tgz", + "integrity": "sha512-n225npDqjDIr967cMScVKHXJs7rout1q+tt50inyBCPkyZ8KxeI6d+GIbSBTT/w/9WdlWDOej3V9HE5Lgk57gw==", "requires": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-dotall-regex": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.18.6.tgz", - "integrity": "sha512-6S3jpun1eEbAxq7TdjLotAsl4WpQI9DxfkycRcKrjhQYzU87qpXdknpBg/e+TdcMehqGnLFi7tnFUBR02Vq6wg==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.23.3.tgz", + "integrity": "sha512-vgnFYDHAKzFaTVp+mneDsIEbnJ2Np/9ng9iviHw3P/KVcgONxpNULEW/51Z/BaFojG2GI2GwwXck5uV1+1NOYQ==", "requires": { - "@babel/helper-create-regexp-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-duplicate-keys": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.18.9.tgz", - "integrity": "sha512-d2bmXCtZXYc59/0SanQKbiWINadaJXqtvIQIzd4+hNwkWBgyCd5F/2t1kXoUdvPMrxzPvhK6EMQRROxsue+mfw==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.23.3.tgz", + "integrity": "sha512-RrqQ+BQmU3Oyav3J+7/myfvRCq7Tbz+kKLLshUmMwNlDHExbGL7ARhajvoBJEvc+fCguPPu887N+3RRXBVKZUA==", "requires": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-dynamic-import": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.23.3.tgz", + "integrity": "sha512-vTG+cTGxPFou12Rj7ll+eD5yWeNl5/8xvQvF08y5Gv3v4mZQoyFf8/n9zg4q5vvCWt5jmgymfzMAldO7orBn7A==", + "requires": { + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-dynamic-import": "^7.8.3" } }, "@babel/plugin-transform-exponentiation-operator": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.18.6.tgz", - "integrity": "sha512-wzEtc0+2c88FVR34aQmiz56dxEkxr2g8DQb/KfaFa1JYXOFVsbhvAonFN6PwVWj++fKmku8NP80plJ5Et4wqHw==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.23.3.tgz", + "integrity": "sha512-5fhCsl1odX96u7ILKHBj4/Y8vipoqwsJMh4csSA8qFfxrZDEA4Ssku2DyNvMJSmZNOEBT750LfFPbtrnTP90BQ==", "requires": { - "@babel/helper-builder-binary-assignment-operator-visitor": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-builder-binary-assignment-operator-visitor": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-export-namespace-from": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.23.3.tgz", + "integrity": "sha512-yCLhW34wpJWRdTxxWtFZASJisihrfyMOTOQexhVzA78jlU+dH7Dw+zQgcPepQ5F3C6bAIiblZZ+qBggJdHiBAg==", + "requires": { + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-export-namespace-from": "^7.8.3" } }, "@babel/plugin-transform-for-of": { - "version": "7.18.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.18.8.tgz", - "integrity": "sha512-yEfTRnjuskWYo0k1mHUqrVWaZwrdq8AYbfrpqULOJOaucGSp4mNMVps+YtA8byoevxS/urwU75vyhQIxcCgiBQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.23.3.tgz", + "integrity": "sha512-X8jSm8X1CMwxmK878qsUGJRmbysKNbdpTv/O1/v0LuY/ZkZrng5WYiekYSdg9m09OTmDDUWeEDsTE+17WYbAZw==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-function-name": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.18.9.tgz", - "integrity": "sha512-WvIBoRPaJQ5yVHzcnJFor7oS5Ls0PYixlTYE63lCj2RtdQEl15M68FXQlxnG6wdraJIXRdR7KI+hQ7q/9QjrCQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.23.3.tgz", + "integrity": "sha512-I1QXp1LxIvt8yLaib49dRW5Okt7Q4oaxao6tFVKS/anCdEOMtYwWVKoiOA1p34GOWIZjUK0E+zCp7+l1pfQyiw==", "requires": { - "@babel/helper-compilation-targets": "^7.18.9", - "@babel/helper-function-name": "^7.18.9", - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-compilation-targets": "^7.22.15", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-json-strings": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.23.3.tgz", + "integrity": "sha512-H9Ej2OiISIZowZHaBwF0tsJOih1PftXJtE8EWqlEIwpc7LMTGq0rPOrywKLQ4nefzx8/HMR0D3JGXoMHYvhi0A==", + "requires": { + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-json-strings": "^7.8.3" } }, "@babel/plugin-transform-literals": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.18.9.tgz", - "integrity": "sha512-IFQDSRoTPnrAIrI5zoZv73IFeZu2dhu6irxQjY9rNjTT53VmKg9fenjvoiOWOkJ6mm4jKVPtdMzBY98Fp4Z4cg==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.23.3.tgz", + "integrity": "sha512-wZ0PIXRxnwZvl9AYpqNUxpZ5BiTGrYt7kueGQ+N5FiQ7RCOD4cm8iShd6S6ggfVIWaJf2EMk8eRzAh52RfP4rQ==", "requires": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-logical-assignment-operators": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.23.3.tgz", + "integrity": "sha512-+pD5ZbxofyOygEp+zZAfujY2ShNCXRpDRIPOiBmTO693hhyOEteZgl876Xs9SAHPQpcV0vz8LvA/T+w8AzyX8A==", + "requires": { + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4" } }, "@babel/plugin-transform-member-expression-literals": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.18.6.tgz", - "integrity": "sha512-qSF1ihLGO3q+/g48k85tUjD033C29TNTVB2paCwZPVmOsjn9pClvYYrM2VeJpBY2bcNkuny0YUyTNRyRxJ54KA==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.23.3.tgz", + "integrity": "sha512-sC3LdDBDi5x96LA+Ytekz2ZPk8i/Ck+DEuDbRAll5rknJ5XRTSaPKEYwomLcs1AA8wg9b3KjIQRsnApj+q51Ag==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-modules-amd": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.18.6.tgz", - "integrity": "sha512-Pra5aXsmTsOnjM3IajS8rTaLCy++nGM4v3YR4esk5PCsyg9z8NA5oQLwxzMUtDBd8F+UmVza3VxoAaWCbzH1rg==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.23.3.tgz", + "integrity": "sha512-vJYQGxeKM4t8hYCKVBlZX/gtIY2I7mRGFNcm85sgXGMTBcoV3QdVtdpbcWEbzbfUIUZKwvgFT82mRvaQIebZzw==", "requires": { - "@babel/helper-module-transforms": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "babel-plugin-dynamic-import-node": "^2.3.3" + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-modules-commonjs": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.18.6.tgz", - "integrity": "sha512-Qfv2ZOWikpvmedXQJDSbxNqy7Xr/j2Y8/KfijM0iJyKkBTmWuvCA1yeH1yDM7NJhBW/2aXxeucLj6i80/LAJ/Q==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.23.3.tgz", + "integrity": "sha512-aVS0F65LKsdNOtcz6FRCpE4OgsP2OFnW46qNxNIX9h3wuzaNcSQsJysuMwqSibC98HPrf2vCgtxKNwS0DAlgcA==", + "requires": { + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-simple-access": "^7.22.5" + } + }, + "@babel/plugin-transform-modules-systemjs": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.23.3.tgz", + "integrity": "sha512-ZxyKGTkF9xT9YJuKQRo19ewf3pXpopuYQd8cDXqNzc3mUNbOME0RKMoZxviQk74hwzfQsEe66dE92MaZbdHKNQ==", + "requires": { + "@babel/helper-hoist-variables": "^7.22.5", + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-validator-identifier": "^7.22.20" + } + }, + "@babel/plugin-transform-modules-umd": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.23.3.tgz", + "integrity": "sha512-zHsy9iXX2nIsCBFPud3jKn1IRPWg3Ing1qOZgeKV39m1ZgIdpJqvlWVeiHBZC6ITRG0MfskhYe9cLgntfSFPIg==", + "requires": { + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-named-capturing-groups-regex": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.22.5.tgz", + "integrity": "sha512-YgLLKmS3aUBhHaxp5hi1WJTgOUb/NCuDHzGT9z9WTt3YG+CPRhJs6nprbStx6DnWM4dh6gt7SU3sZodbZ08adQ==", + "requires": { + "@babel/helper-create-regexp-features-plugin": "^7.22.5", + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-new-target": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.23.3.tgz", + "integrity": "sha512-YJ3xKqtJMAT5/TIZnpAR3I+K+WaDowYbN3xyxI8zxx/Gsypwf9B9h0VB+1Nh6ACAAPRS5NSRje0uVv5i79HYGQ==", + "requires": { + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-nullish-coalescing-operator": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.23.3.tgz", + "integrity": "sha512-xzg24Lnld4DYIdysyf07zJ1P+iIfJpxtVFOzX4g+bsJ3Ng5Le7rXx9KwqKzuyaUeRnt+I1EICwQITqc0E2PmpA==", + "requires": { + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3" + } + }, + "@babel/plugin-transform-numeric-separator": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.23.3.tgz", + "integrity": "sha512-s9GO7fIBi/BLsZ0v3Rftr6Oe4t0ctJ8h4CCXfPoEJwmvAPMyNrfkOOJzm6b9PX9YXcCJWWQd/sBF/N26eBiMVw==", + "requires": { + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-numeric-separator": "^7.10.4" + } + }, + "@babel/plugin-transform-object-rest-spread": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.23.3.tgz", + "integrity": "sha512-VxHt0ANkDmu8TANdE9Kc0rndo/ccsmfe2Cx2y5sI4hu3AukHQ5wAu4cM7j3ba8B9548ijVyclBU+nuDQftZsog==", "requires": { - "@babel/helper-module-transforms": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-simple-access": "^7.18.6", - "babel-plugin-dynamic-import-node": "^2.3.3" + "@babel/compat-data": "^7.23.3", + "@babel/helper-compilation-targets": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-transform-parameters": "^7.23.3" } }, - "@babel/plugin-transform-modules-systemjs": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.18.9.tgz", - "integrity": "sha512-zY/VSIbbqtoRoJKo2cDTewL364jSlZGvn0LKOf9ntbfxOvjfmyrdtEEOAdswOswhZEb8UH3jDkCKHd1sPgsS0A==", + "@babel/plugin-transform-object-super": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.23.3.tgz", + "integrity": "sha512-BwQ8q0x2JG+3lxCVFohg+KbQM7plfpBwThdW9A6TMtWwLsbDA01Ek2Zb/AgDN39BiZsExm4qrXxjk+P1/fzGrA==", "requires": { - "@babel/helper-hoist-variables": "^7.18.6", - "@babel/helper-module-transforms": "^7.18.9", - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-validator-identifier": "^7.18.6", - "babel-plugin-dynamic-import-node": "^2.3.3" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-replace-supers": "^7.22.20" } }, - "@babel/plugin-transform-modules-umd": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.18.6.tgz", - "integrity": "sha512-dcegErExVeXcRqNtkRU/z8WlBLnvD4MRnHgNs3MytRO1Mn1sHRyhbcpYbVMGclAqOjdW+9cfkdZno9dFdfKLfQ==", + "@babel/plugin-transform-optional-catch-binding": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.23.3.tgz", + "integrity": "sha512-LxYSb0iLjUamfm7f1D7GpiS4j0UAC8AOiehnsGAP8BEsIX8EOi3qV6bbctw8M7ZvLtcoZfZX5Z7rN9PlWk0m5A==", "requires": { - "@babel/helper-module-transforms": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3" } }, - "@babel/plugin-transform-named-capturing-groups-regex": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.18.6.tgz", - "integrity": "sha512-UmEOGF8XgaIqD74bC8g7iV3RYj8lMf0Bw7NJzvnS9qQhM4mg+1WHKotUIdjxgD2RGrgFLZZPCFPFj3P/kVDYhg==", + "@babel/plugin-transform-optional-chaining": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.23.3.tgz", + "integrity": "sha512-zvL8vIfIUgMccIAK1lxjvNv572JHFJIKb4MWBz5OGdBQA0fB0Xluix5rmOby48exiJc987neOmP/m9Fnpkz3Tg==", "requires": { - "@babel/helper-create-regexp-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5", + "@babel/plugin-syntax-optional-chaining": "^7.8.3" } }, - "@babel/plugin-transform-new-target": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.18.6.tgz", - "integrity": "sha512-DjwFA/9Iu3Z+vrAn+8pBUGcjhxKguSMlsFqeCKbhb9BAV756v0krzVK04CRDi/4aqmk8BsHb4a/gFcaA5joXRw==", + "@babel/plugin-transform-parameters": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.23.3.tgz", + "integrity": "sha512-09lMt6UsUb3/34BbECKVbVwrT9bO6lILWln237z7sLaWnMsTi7Yc9fhX5DLpkJzAGfaReXI22wP41SZmnAA3Vw==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" } }, - "@babel/plugin-transform-object-super": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.18.6.tgz", - "integrity": "sha512-uvGz6zk+pZoS1aTZrOvrbj6Pp/kK2mp45t2B+bTDre2UgsZZ8EZLSJtUg7m/no0zOJUWgFONpB7Zv9W2tSaFlA==", + "@babel/plugin-transform-private-methods": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.23.3.tgz", + "integrity": "sha512-UzqRcRtWsDMTLrRWFvUBDwmw06tCQH9Rl1uAjfh6ijMSmGYQ+fpdB+cnqRC8EMh5tuuxSv0/TejGL+7vyj+50g==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-replace-supers": "^7.18.6" + "@babel/helper-create-class-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" } }, - "@babel/plugin-transform-parameters": { - "version": "7.18.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.18.8.tgz", - "integrity": "sha512-ivfbE3X2Ss+Fj8nnXvKJS6sjRG4gzwPMsP+taZC+ZzEGjAYlvENixmt1sZ5Ca6tWls+BlKSGKPJ6OOXvXCbkFg==", + "@babel/plugin-transform-private-property-in-object": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.23.3.tgz", + "integrity": "sha512-a5m2oLNFyje2e/rGKjVfAELTVI5mbA0FeZpBnkOWWV7eSmKQ+T/XW0Vf+29ScLzSxX+rnsarvU0oie/4m6hkxA==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-create-class-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5" } }, "@babel/plugin-transform-property-literals": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.18.6.tgz", - "integrity": "sha512-cYcs6qlgafTud3PAzrrRNbQtfpQ8+y/+M5tKmksS9+M1ckbH6kzY8MrexEM9mcA6JDsukE19iIRvAyYl463sMg==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.23.3.tgz", + "integrity": "sha512-jR3Jn3y7cZp4oEWPFAlRsSWjxKe4PZILGBSd4nis1TsC5qeSpb+nrtihJuDhNI7QHiVbUaiXa0X2RZY3/TI6Nw==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-react-constant-elements": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.18.9.tgz", - "integrity": "sha512-IrTYh1I3YCEL1trjknnlLKTp5JggjzhKl/d3ibzPc97JhpFcDTr38Jdek/oX4cFbS6By0bXJcOkpRvJ5ZHK2wQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.23.3.tgz", + "integrity": "sha512-zP0QKq/p6O42OL94udMgSfKXyse4RyJ0JqbQ34zDAONWjyrEsghYEyTSK5FIpmXmCpB55SHokL1cRRKHv8L2Qw==", "requires": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-react-display-name": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.18.6.tgz", - "integrity": "sha512-TV4sQ+T013n61uMoygyMRm+xf04Bd5oqFpv2jAEQwSZ8NwQA7zeRPg1LMVg2PWi3zWBz+CLKD+v5bcpZ/BS0aA==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.23.3.tgz", + "integrity": "sha512-GnvhtVfA2OAtzdX58FJxU19rhoGeQzyVndw3GgtdECQvQFXPEZIOVULHVZGAYmOgmqjXpVpfocAbSjh99V/Fqw==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-react-jsx": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.18.6.tgz", - "integrity": "sha512-Mz7xMPxoy9kPS/JScj6fJs03TZ/fZ1dJPlMjRAgTaxaS0fUBk8FV/A2rRgfPsVCZqALNwMexD+0Uaf5zlcKPpw==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.22.15.tgz", + "integrity": "sha512-oKckg2eZFa8771O/5vi7XeTvmM6+O9cxZu+kanTU7tD4sin5nO/G8jGJhq8Hvt2Z0kUoEDRayuZLaUlYl8QuGA==", "requires": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-module-imports": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-jsx": "^7.18.6", - "@babel/types": "^7.18.6" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-jsx": "^7.22.5", + "@babel/types": "^7.22.15" } }, "@babel/plugin-transform-react-jsx-development": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.18.6.tgz", - "integrity": "sha512-SA6HEjwYFKF7WDjWcMcMGUimmw/nhNRDWxr+KaLSCrkD/LMDBvWRmHAYgE1HDeF8KUuI8OAu+RT6EOtKxSW2qA==", + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.22.5.tgz", + "integrity": "sha512-bDhuzwWMuInwCYeDeMzyi7TaBgRQei6DqxhbyniL7/VG4RSS7HtSL2QbY4eESy1KJqlWt8g3xeEBGPuo+XqC8A==", "requires": { - "@babel/plugin-transform-react-jsx": "^7.18.6" + "@babel/plugin-transform-react-jsx": "^7.22.5" } }, "@babel/plugin-transform-react-pure-annotations": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.18.6.tgz", - "integrity": "sha512-I8VfEPg9r2TRDdvnHgPepTKvuRomzA8+u+nhY7qSI1fR2hRNebasZEETLyM5mAUr0Ku56OkXJ0I7NHJnO6cJiQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.23.3.tgz", + "integrity": "sha512-qMFdSS+TUhB7Q/3HVPnEdYJDQIk57jkntAwSuz9xfSE4n+3I+vHYCli3HoHawN1Z3RfCz/y1zXA/JXjG6cVImQ==", "requires": { - "@babel/helper-annotate-as-pure": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-regenerator": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.18.6.tgz", - "integrity": "sha512-poqRI2+qiSdeldcz4wTSTXBRryoq3Gc70ye7m7UD5Ww0nE29IXqMl6r7Nd15WBgRd74vloEMlShtH6CKxVzfmQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.23.3.tgz", + "integrity": "sha512-KP+75h0KghBMcVpuKisx3XTu9Ncut8Q8TuvGO4IhY+9D5DFEckQefOuIsB/gQ2tG71lCke4NMrtIPS8pOj18BQ==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6", - "regenerator-transform": "^0.15.0" + "@babel/helper-plugin-utils": "^7.22.5", + "regenerator-transform": "^0.15.2" } }, "@babel/plugin-transform-reserved-words": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.18.6.tgz", - "integrity": "sha512-oX/4MyMoypzHjFrT1CdivfKZ+XvIPMFXwwxHp/r0Ddy2Vuomt4HDFGmft1TAY2yiTKiNSsh3kjBAzcM8kSdsjA==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.23.3.tgz", + "integrity": "sha512-QnNTazY54YqgGxwIexMZva9gqbPa15t/x9VS+0fsEFWplwVpXYZivtgl43Z1vMpc1bdPP2PP8siFeVcnFvA3Cg==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-runtime": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.18.9.tgz", - "integrity": "sha512-wS8uJwBt7/b/mzE13ktsJdmS4JP/j7PQSaADtnb4I2wL0zK51MQ0pmF8/Jy0wUIS96fr+fXT6S/ifiPXnvrlSg==", - "requires": { - "@babel/helper-module-imports": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.9", - "babel-plugin-polyfill-corejs2": "^0.3.1", - "babel-plugin-polyfill-corejs3": "^0.5.2", - "babel-plugin-polyfill-regenerator": "^0.3.1", - "semver": "^6.3.0" + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.23.3.tgz", + "integrity": "sha512-XcQ3X58CKBdBnnZpPaQjgVMePsXtSZzHoku70q9tUAQp02ggPQNM04BF3RvlW1GSM/McbSOQAzEK4MXbS7/JFg==", + "requires": { + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "babel-plugin-polyfill-corejs2": "^0.4.6", + "babel-plugin-polyfill-corejs3": "^0.8.5", + "babel-plugin-polyfill-regenerator": "^0.5.3", + "semver": "^6.3.1" }, "dependencies": { "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==" } } }, "@babel/plugin-transform-shorthand-properties": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.18.6.tgz", - "integrity": "sha512-eCLXXJqv8okzg86ywZJbRn19YJHU4XUa55oz2wbHhaQVn/MM+XhukiT7SYqp/7o00dg52Rj51Ny+Ecw4oyoygw==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.23.3.tgz", + "integrity": "sha512-ED2fgqZLmexWiN+YNFX26fx4gh5qHDhn1O2gvEhreLW2iI63Sqm4llRLCXALKrCnbN4Jy0VcMQZl/SAzqug/jg==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-spread": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.18.9.tgz", - "integrity": "sha512-39Q814wyoOPtIB/qGopNIL9xDChOE1pNU0ZY5dO0owhiVt/5kFm4li+/bBtwc7QotG0u5EPzqhZdjMtmqBqyQA==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.23.3.tgz", + "integrity": "sha512-VvfVYlrlBVu+77xVTOAoxQ6mZbnIq5FM0aGBSFEcIh03qHf+zNqA4DC/3XMUozTg7bZV3e3mZQ0i13VB6v5yUg==", "requires": { - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-skip-transparent-expression-wrappers": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5" } }, "@babel/plugin-transform-sticky-regex": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.18.6.tgz", - "integrity": "sha512-kfiDrDQ+PBsQDO85yj1icueWMfGfJFKN1KCkndygtu/C9+XUfydLC8Iv5UYJqRwy4zk8EcplRxEOeLyjq1gm6Q==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.23.3.tgz", + "integrity": "sha512-HZOyN9g+rtvnOU3Yh7kSxXrKbzgrm5X4GncPY1QOquu7epga5MxKHVpYu2hvQnry/H+JjckSYRb93iNfsioAGg==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-template-literals": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.18.9.tgz", - "integrity": "sha512-S8cOWfT82gTezpYOiVaGHrCbhlHgKhQt8XH5ES46P2XWmX92yisoZywf5km75wv5sYcXDUCLMmMxOLCtthDgMA==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.23.3.tgz", + "integrity": "sha512-Flok06AYNp7GV2oJPZZcP9vZdszev6vPBkHLwxwSpaIqx75wn6mUd3UFWsSsA0l8nXAKkyCmL/sR02m8RYGeHg==", "requires": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-typeof-symbol": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.18.9.tgz", - "integrity": "sha512-SRfwTtF11G2aemAZWivL7PD+C9z52v9EvMqH9BuYbabyPuKUvSWks3oCg6041pT925L4zVFqaVBeECwsmlguEw==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.23.3.tgz", + "integrity": "sha512-4t15ViVnaFdrPC74be1gXBSMzXk3B4Us9lP7uLRQHTFpV5Dvt33pn+2MyyNxmN3VTTm3oTrZVMUmuw3oBnQ2oQ==", "requires": { - "@babel/helper-plugin-utils": "^7.18.9" + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-typescript": { - "version": "7.18.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.18.8.tgz", - "integrity": "sha512-p2xM8HI83UObjsZGofMV/EdYjamsDm6MoN3hXPYIT0+gxIoopE+B7rPYKAxfrz9K9PK7JafTTjqYC6qipLExYA==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.23.3.tgz", + "integrity": "sha512-ogV0yWnq38CFwH20l2Afz0dfKuZBx9o/Y2Rmh5vuSS0YD1hswgEgTfyTzuSrT2q9btmHRSqYoSfwFUVaC1M1Jw==", "requires": { - "@babel/helper-create-class-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/plugin-syntax-typescript": "^7.18.6" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-create-class-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-typescript": "^7.23.3" } }, "@babel/plugin-transform-unicode-escapes": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.18.6.tgz", - "integrity": "sha512-XNRwQUXYMP7VLuy54cr/KS/WeL3AZeORhrmeZ7iewgu+X2eBqmpaLI/hzqr9ZxCeUoq0ASK4GUzSM0BDhZkLFw==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.23.3.tgz", + "integrity": "sha512-OMCUx/bU6ChE3r4+ZdylEqAjaQgHAgipgW8nsCfu5pGqDcFytVd91AwRvUJSBZDz0exPGgnjoqhgRYLRjFZc9Q==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-unicode-property-regex": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.23.3.tgz", + "integrity": "sha512-KcLIm+pDZkWZQAFJ9pdfmh89EwVfmNovFBcXko8szpBeF8z68kWIPeKlmSOkT9BXJxs2C0uk+5LxoxIv62MROA==", + "requires": { + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/plugin-transform-unicode-regex": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.18.6.tgz", - "integrity": "sha512-gE7A6Lt7YLnNOL3Pb9BNeZvi+d8l7tcRrG4+pwJjK9hD2xX4mEvjlQW60G9EEmfXVYRPv9VRQcyegIVHCql/AA==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.23.3.tgz", + "integrity": "sha512-wMHpNA4x2cIA32b/ci3AfwNgheiva2W0WUKWTK7vBHBhDKfPsc5cFGNWm69WBqpwd86u1qwZ9PWevKqm1A3yAw==", "requires": { - "@babel/helper-create-regexp-features-plugin": "^7.18.6", - "@babel/helper-plugin-utils": "^7.18.6" + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" + } + }, + "@babel/plugin-transform-unicode-sets-regex": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.23.3.tgz", + "integrity": "sha512-W7lliA/v9bNR83Qc3q1ip9CQMZ09CcHDbHfbLRDNuAhn1Mvkr1ZNF7hPmztMQvtTGVLJ9m8IZqWsTkXOml8dbw==", + "requires": { + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5" } }, "@babel/preset-env": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.18.9.tgz", - "integrity": "sha512-75pt/q95cMIHWssYtyfjVlvI+QEZQThQbKvR9xH+F/Agtw/s4Wfc2V9Bwd/P39VtixB7oWxGdH4GteTTwYJWMg==", - "requires": { - "@babel/compat-data": "^7.18.8", - "@babel/helper-compilation-targets": "^7.18.9", - "@babel/helper-plugin-utils": "^7.18.9", - "@babel/helper-validator-option": "^7.18.6", - "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.18.6", - "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.18.9", - "@babel/plugin-proposal-async-generator-functions": "^7.18.6", - "@babel/plugin-proposal-class-properties": "^7.18.6", - "@babel/plugin-proposal-class-static-block": "^7.18.6", - "@babel/plugin-proposal-dynamic-import": "^7.18.6", - "@babel/plugin-proposal-export-namespace-from": "^7.18.9", - "@babel/plugin-proposal-json-strings": "^7.18.6", - "@babel/plugin-proposal-logical-assignment-operators": "^7.18.9", - "@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.6", - "@babel/plugin-proposal-numeric-separator": "^7.18.6", - "@babel/plugin-proposal-object-rest-spread": "^7.18.9", - "@babel/plugin-proposal-optional-catch-binding": "^7.18.6", - "@babel/plugin-proposal-optional-chaining": "^7.18.9", - "@babel/plugin-proposal-private-methods": "^7.18.6", - "@babel/plugin-proposal-private-property-in-object": "^7.18.6", - "@babel/plugin-proposal-unicode-property-regex": "^7.18.6", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.23.3.tgz", + "integrity": "sha512-ovzGc2uuyNfNAs/jyjIGxS8arOHS5FENZaNn4rtE7UdKMMkqHCvboHfcuhWLZNX5cB44QfcGNWjaevxMzzMf+Q==", + "requires": { + "@babel/compat-data": "^7.23.3", + "@babel/helper-compilation-targets": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-validator-option": "^7.22.15", + "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.23.3", + "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.23.3", + "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.23.3", + "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2", "@babel/plugin-syntax-async-generators": "^7.8.4", "@babel/plugin-syntax-class-properties": "^7.12.13", "@babel/plugin-syntax-class-static-block": "^7.14.5", "@babel/plugin-syntax-dynamic-import": "^7.8.3", "@babel/plugin-syntax-export-namespace-from": "^7.8.3", - "@babel/plugin-syntax-import-assertions": "^7.18.6", + "@babel/plugin-syntax-import-assertions": "^7.23.3", + "@babel/plugin-syntax-import-attributes": "^7.23.3", + "@babel/plugin-syntax-import-meta": "^7.10.4", "@babel/plugin-syntax-json-strings": "^7.8.3", "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4", "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", @@ -14535,139 +15055,161 @@ "@babel/plugin-syntax-optional-chaining": "^7.8.3", "@babel/plugin-syntax-private-property-in-object": "^7.14.5", "@babel/plugin-syntax-top-level-await": "^7.14.5", - "@babel/plugin-transform-arrow-functions": "^7.18.6", - "@babel/plugin-transform-async-to-generator": "^7.18.6", - "@babel/plugin-transform-block-scoped-functions": "^7.18.6", - "@babel/plugin-transform-block-scoping": "^7.18.9", - "@babel/plugin-transform-classes": "^7.18.9", - "@babel/plugin-transform-computed-properties": "^7.18.9", - "@babel/plugin-transform-destructuring": "^7.18.9", - "@babel/plugin-transform-dotall-regex": "^7.18.6", - "@babel/plugin-transform-duplicate-keys": "^7.18.9", - "@babel/plugin-transform-exponentiation-operator": "^7.18.6", - "@babel/plugin-transform-for-of": "^7.18.8", - "@babel/plugin-transform-function-name": "^7.18.9", - "@babel/plugin-transform-literals": "^7.18.9", - "@babel/plugin-transform-member-expression-literals": "^7.18.6", - "@babel/plugin-transform-modules-amd": "^7.18.6", - "@babel/plugin-transform-modules-commonjs": "^7.18.6", - "@babel/plugin-transform-modules-systemjs": "^7.18.9", - "@babel/plugin-transform-modules-umd": "^7.18.6", - "@babel/plugin-transform-named-capturing-groups-regex": "^7.18.6", - "@babel/plugin-transform-new-target": "^7.18.6", - "@babel/plugin-transform-object-super": "^7.18.6", - "@babel/plugin-transform-parameters": "^7.18.8", - "@babel/plugin-transform-property-literals": "^7.18.6", - "@babel/plugin-transform-regenerator": "^7.18.6", - "@babel/plugin-transform-reserved-words": "^7.18.6", - "@babel/plugin-transform-shorthand-properties": "^7.18.6", - "@babel/plugin-transform-spread": "^7.18.9", - "@babel/plugin-transform-sticky-regex": "^7.18.6", - "@babel/plugin-transform-template-literals": "^7.18.9", - "@babel/plugin-transform-typeof-symbol": "^7.18.9", - "@babel/plugin-transform-unicode-escapes": "^7.18.6", - "@babel/plugin-transform-unicode-regex": "^7.18.6", - "@babel/preset-modules": "^0.1.5", - "@babel/types": "^7.18.9", - "babel-plugin-polyfill-corejs2": "^0.3.1", - "babel-plugin-polyfill-corejs3": "^0.5.2", - "babel-plugin-polyfill-regenerator": "^0.3.1", - "core-js-compat": "^3.22.1", - "semver": "^6.3.0" + "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6", + "@babel/plugin-transform-arrow-functions": "^7.23.3", + "@babel/plugin-transform-async-generator-functions": "^7.23.3", + "@babel/plugin-transform-async-to-generator": "^7.23.3", + "@babel/plugin-transform-block-scoped-functions": "^7.23.3", + "@babel/plugin-transform-block-scoping": "^7.23.3", + "@babel/plugin-transform-class-properties": "^7.23.3", + "@babel/plugin-transform-class-static-block": "^7.23.3", + "@babel/plugin-transform-classes": "^7.23.3", + "@babel/plugin-transform-computed-properties": "^7.23.3", + "@babel/plugin-transform-destructuring": "^7.23.3", + "@babel/plugin-transform-dotall-regex": "^7.23.3", + "@babel/plugin-transform-duplicate-keys": "^7.23.3", + "@babel/plugin-transform-dynamic-import": "^7.23.3", + "@babel/plugin-transform-exponentiation-operator": "^7.23.3", + "@babel/plugin-transform-export-namespace-from": "^7.23.3", + "@babel/plugin-transform-for-of": "^7.23.3", + "@babel/plugin-transform-function-name": "^7.23.3", + "@babel/plugin-transform-json-strings": "^7.23.3", + "@babel/plugin-transform-literals": "^7.23.3", + "@babel/plugin-transform-logical-assignment-operators": "^7.23.3", + "@babel/plugin-transform-member-expression-literals": "^7.23.3", + "@babel/plugin-transform-modules-amd": "^7.23.3", + "@babel/plugin-transform-modules-commonjs": "^7.23.3", + "@babel/plugin-transform-modules-systemjs": "^7.23.3", + "@babel/plugin-transform-modules-umd": "^7.23.3", + "@babel/plugin-transform-named-capturing-groups-regex": "^7.22.5", + "@babel/plugin-transform-new-target": "^7.23.3", + "@babel/plugin-transform-nullish-coalescing-operator": "^7.23.3", + "@babel/plugin-transform-numeric-separator": "^7.23.3", + "@babel/plugin-transform-object-rest-spread": "^7.23.3", + "@babel/plugin-transform-object-super": "^7.23.3", + "@babel/plugin-transform-optional-catch-binding": "^7.23.3", + "@babel/plugin-transform-optional-chaining": "^7.23.3", + "@babel/plugin-transform-parameters": "^7.23.3", + "@babel/plugin-transform-private-methods": "^7.23.3", + "@babel/plugin-transform-private-property-in-object": "^7.23.3", + "@babel/plugin-transform-property-literals": "^7.23.3", + "@babel/plugin-transform-regenerator": "^7.23.3", + "@babel/plugin-transform-reserved-words": "^7.23.3", + "@babel/plugin-transform-shorthand-properties": "^7.23.3", + "@babel/plugin-transform-spread": "^7.23.3", + "@babel/plugin-transform-sticky-regex": "^7.23.3", + "@babel/plugin-transform-template-literals": "^7.23.3", + "@babel/plugin-transform-typeof-symbol": "^7.23.3", + "@babel/plugin-transform-unicode-escapes": "^7.23.3", + "@babel/plugin-transform-unicode-property-regex": "^7.23.3", + "@babel/plugin-transform-unicode-regex": "^7.23.3", + "@babel/plugin-transform-unicode-sets-regex": "^7.23.3", + "@babel/preset-modules": "0.1.6-no-external-plugins", + "babel-plugin-polyfill-corejs2": "^0.4.6", + "babel-plugin-polyfill-corejs3": "^0.8.5", + "babel-plugin-polyfill-regenerator": "^0.5.3", + "core-js-compat": "^3.31.0", + "semver": "^6.3.1" }, "dependencies": { "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==" } } }, "@babel/preset-modules": { - "version": "0.1.5", - "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.5.tgz", - "integrity": "sha512-A57th6YRG7oR3cq/yt/Y84MvGgE0eJG2F1JLhKuyG+jFxEgrd/HAMJatiFtmOiZurz+0DkrvbheCLaV5f2JfjA==", + "version": "0.1.6-no-external-plugins", + "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz", + "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==", "requires": { "@babel/helper-plugin-utils": "^7.0.0", - "@babel/plugin-proposal-unicode-property-regex": "^7.4.4", - "@babel/plugin-transform-dotall-regex": "^7.4.4", "@babel/types": "^7.4.4", "esutils": "^2.0.2" } }, "@babel/preset-react": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/preset-react/-/preset-react-7.18.6.tgz", - "integrity": "sha512-zXr6atUmyYdiWRVLOZahakYmOBHtWc2WGCkP8PYTgZi0iJXDY2CN180TdrIW4OGOAdLc7TifzDIvtx6izaRIzg==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/preset-react/-/preset-react-7.23.3.tgz", + "integrity": "sha512-tbkHOS9axH6Ysf2OUEqoSZ6T3Fa2SrNH6WTWSPBboxKzdxNc9qOICeLXkNG0ZEwbQ1HY8liwOce4aN/Ceyuq6w==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-validator-option": "^7.18.6", - "@babel/plugin-transform-react-display-name": "^7.18.6", - "@babel/plugin-transform-react-jsx": "^7.18.6", - "@babel/plugin-transform-react-jsx-development": "^7.18.6", - "@babel/plugin-transform-react-pure-annotations": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-validator-option": "^7.22.15", + "@babel/plugin-transform-react-display-name": "^7.23.3", + "@babel/plugin-transform-react-jsx": "^7.22.15", + "@babel/plugin-transform-react-jsx-development": "^7.22.5", + "@babel/plugin-transform-react-pure-annotations": "^7.23.3" } }, "@babel/preset-typescript": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.18.6.tgz", - "integrity": "sha512-s9ik86kXBAnD760aybBucdpnLsAt0jK1xqJn2juOn9lkOvSHV60os5hxoVJsPzMQxvnUJFAlkont2DvvaYEBtQ==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.23.3.tgz", + "integrity": "sha512-17oIGVlqz6CchO9RFYn5U6ZpWRZIngayYCtrPRSgANSwC2V1Jb+iP74nVxzzXJte8b8BYxrL1yY96xfhTBrNNQ==", "requires": { - "@babel/helper-plugin-utils": "^7.18.6", - "@babel/helper-validator-option": "^7.18.6", - "@babel/plugin-transform-typescript": "^7.18.6" + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/helper-validator-option": "^7.22.15", + "@babel/plugin-syntax-jsx": "^7.23.3", + "@babel/plugin-transform-modules-commonjs": "^7.23.3", + "@babel/plugin-transform-typescript": "^7.23.3" } }, + "@babel/regjsgen": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/@babel/regjsgen/-/regjsgen-0.8.0.tgz", + "integrity": "sha512-x/rqGMdzj+fWZvCOYForTghzbtqPDZ5gPwaoNGHdgDfF2QA/XZbCBp4Moo5scrkAMPhB7z26XM/AaHuIJdgauA==" + }, "@babel/runtime": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.18.9.tgz", - "integrity": "sha512-lkqXDcvlFT5rvEjiu6+QYO+1GXrEHRo2LOtS7E4GtX5ESIZOgepqsZBVIj6Pv+a6zqsya9VCgiK1KAK4BvJDAw==", + "version": "7.23.2", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.23.2.tgz", + "integrity": "sha512-mM8eg4yl5D6i3lu2QKPuPH4FArvJ8KhTofbE7jwMUv9KX5mBvwPAqnV3MlyBNqdp9RyRKP6Yck8TrfYrPvX3bg==", "requires": { - "regenerator-runtime": "^0.13.4" + "regenerator-runtime": "^0.14.0" } }, "@babel/runtime-corejs3": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.18.9.tgz", - "integrity": "sha512-qZEWeccZCrHA2Au4/X05QW5CMdm4VjUDCrGq5gf1ZDcM4hRqreKrtwAn7yci9zfgAS9apvnsFXiGBHBAxZdK9A==", + "version": "7.23.2", + "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.23.2.tgz", + "integrity": "sha512-54cIh74Z1rp4oIjsHjqN+WM4fMyCBYe+LpZ9jWm51CZ1fbH3SkAzQD/3XLoNkjbJ7YEmjobLXyvQrFypRHOrXw==", "requires": { - "core-js-pure": "^3.20.2", - "regenerator-runtime": "^0.13.4" + "core-js-pure": "^3.30.2", + "regenerator-runtime": "^0.14.0" } }, "@babel/template": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.18.6.tgz", - "integrity": "sha512-JoDWzPe+wgBsTTgdnIma3iHNFC7YVJoPssVBDjiHfNlyt4YcunDtcDOUmfVDfCK5MfdsaIoX9PkijPhjH3nYUw==", + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.22.15.tgz", + "integrity": "sha512-QPErUVm4uyJa60rkI73qneDacvdvzxshT3kksGqlGWYdOTIUOwJ7RDUL8sGqslY1uXWSL6xMFKEXDS3ox2uF0w==", "requires": { - "@babel/code-frame": "^7.18.6", - "@babel/parser": "^7.18.6", - "@babel/types": "^7.18.6" + "@babel/code-frame": "^7.22.13", + "@babel/parser": "^7.22.15", + "@babel/types": "^7.22.15" } }, "@babel/traverse": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.18.9.tgz", - "integrity": "sha512-LcPAnujXGwBgv3/WHv01pHtb2tihcyW1XuL9wd7jqh1Z8AQkTd+QVjMrMijrln0T7ED3UXLIy36P9Ao7W75rYg==", - "requires": { - "@babel/code-frame": "^7.18.6", - "@babel/generator": "^7.18.9", - "@babel/helper-environment-visitor": "^7.18.9", - "@babel/helper-function-name": "^7.18.9", - "@babel/helper-hoist-variables": "^7.18.6", - "@babel/helper-split-export-declaration": "^7.18.6", - "@babel/parser": "^7.18.9", - "@babel/types": "^7.18.9", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.23.3.tgz", + "integrity": "sha512-+K0yF1/9yR0oHdE0StHuEj3uTPzwwbrLGfNOndVJVV2TqA5+j3oljJUb4nmB954FLGjNem976+B+eDuLIjesiQ==", + "requires": { + "@babel/code-frame": "^7.22.13", + "@babel/generator": "^7.23.3", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-hoist-variables": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.6", + "@babel/parser": "^7.23.3", + "@babel/types": "^7.23.3", "debug": "^4.1.0", "globals": "^11.1.0" } }, "@babel/types": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.18.9.tgz", - "integrity": "sha512-WwMLAg2MvJmt/rKEVQBBhIVffMmnilX4oe0sRe7iPOHIGsqpruFHHdrfj4O1CMMtgMtCU4oPafZjDPCRgO57Wg==", + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.23.3.tgz", + "integrity": "sha512-OZnvoH2l8PK5eUvEcUyCt/sXgr/h+UWpVuBbOljwcrAgUl6lpchoQ++PHGyQy1AtYnVA6CEq3y5xeEI10brpXw==", "requires": { - "@babel/helper-validator-identifier": "^7.18.6", + "@babel/helper-string-parser": "^7.22.5", + "@babel/helper-validator-identifier": "^7.22.20", "to-fast-properties": "^2.0.0" } }, @@ -14677,20 +15219,25 @@ "integrity": "sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==", "optional": true }, + "@discoveryjs/json-ext": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz", + "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==" + }, "@docsearch/css": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-3.1.1.tgz", - "integrity": "sha512-utLgg7E1agqQeqCJn05DWC7XXMk4tMUUnL7MZupcknRu2OzGN13qwey2qA/0NAKkVBGugiWtON0+rlU0QIPojg==" + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-3.6.0.tgz", + "integrity": "sha512-+sbxb71sWre+PwDK7X2T8+bhS6clcVMLwBPznX45Qu6opJcgRjAp7gYSDzVFp187J+feSj5dNBN1mJoi6ckkUQ==" }, "@docsearch/react": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-3.1.1.tgz", - "integrity": "sha512-cfoql4qvtsVRqBMYxhlGNpvyy/KlCoPqjIsJSZYqYf9AplZncKjLBTcwBu6RXFMVCe30cIFljniI4OjqAU67pQ==", + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-3.6.0.tgz", + "integrity": "sha512-HUFut4ztcVNmqy9gp/wxNbC7pTOHhgVVkHVGCACTuLhUKUhKAF9KYHJtMiLUJxEqiFLQiuri1fWF8zqwM/cu1w==", "requires": { - "@algolia/autocomplete-core": "1.7.1", - "@algolia/autocomplete-preset-algolia": "1.7.1", - "@docsearch/css": "3.1.1", - "algoliasearch": "^4.0.0" + "@algolia/autocomplete-core": "1.9.3", + "@algolia/autocomplete-preset-algolia": "1.9.3", + "@docsearch/css": "3.6.0", + "algoliasearch": "^4.19.1" } }, "@docusaurus/core": { @@ -15024,14 +15571,14 @@ } }, "@docusaurus/theme-live-codeblock": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/theme-live-codeblock/-/theme-live-codeblock-2.0.0-rc.1.tgz", - "integrity": "sha512-Sak7ZmznJIdTVConB1WQeGa9vQsCgkglPO6epqCTBHmfakEl9BHTBK+X/zoj7fWeX1DxD5UQ9/DiU8LAaIjLyA==", - "requires": { - "@docusaurus/core": "2.0.0-rc.1", - "@docusaurus/theme-common": "2.0.0-rc.1", - "@docusaurus/theme-translations": "2.0.0-rc.1", - "@docusaurus/utils-validation": "2.0.0-rc.1", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/theme-live-codeblock/-/theme-live-codeblock-2.4.3.tgz", + "integrity": "sha512-wx+iJCCoSewUkMzFy7pnbhDBCRcJRTLkpx1/zwnHhfiNWVvJ2XjtBKIviRyMhynZYyvO4sLTpCclzK8JOctkxw==", + "requires": { + "@docusaurus/core": "2.4.3", + "@docusaurus/theme-common": "2.4.3", + "@docusaurus/theme-translations": "2.4.3", + "@docusaurus/utils-validation": "2.4.3", "@philpl/buble": "^0.19.7", "clsx": "^1.2.1", "fs-extra": "^10.1.0", @@ -15040,9 +15587,9 @@ }, "dependencies": { "@docusaurus/core": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/core/-/core-2.0.0-rc.1.tgz", - "integrity": "sha512-b9FX0Z+EddfQ6wAiNh+Wx4fysKfcvEcWJrZ5USROn3C+EVU5P4luaa8mwWK//O+hTwD9ur7/A44IZ/tWCTAoLQ==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/core/-/core-2.4.3.tgz", + "integrity": "sha512-dWH5P7cgeNSIg9ufReX6gaCl/TmrGKD38Orbwuz05WPhAQtFXHd5B8Qym1TiXfvUNvwoYKkAJOJuGe8ou0Z7PA==", "requires": { "@babel/core": "^7.18.6", "@babel/generator": "^7.18.7", @@ -15054,13 +15601,13 @@ "@babel/runtime": "^7.18.6", "@babel/runtime-corejs3": "^7.18.6", "@babel/traverse": "^7.18.8", - "@docusaurus/cssnano-preset": "2.0.0-rc.1", - "@docusaurus/logger": "2.0.0-rc.1", - "@docusaurus/mdx-loader": "2.0.0-rc.1", + "@docusaurus/cssnano-preset": "2.4.3", + "@docusaurus/logger": "2.4.3", + "@docusaurus/mdx-loader": "2.4.3", "@docusaurus/react-loadable": "5.5.2", - "@docusaurus/utils": "2.0.0-rc.1", - "@docusaurus/utils-common": "2.0.0-rc.1", - "@docusaurus/utils-validation": "2.0.0-rc.1", + "@docusaurus/utils": "2.4.3", + "@docusaurus/utils-common": "2.4.3", + "@docusaurus/utils-validation": "2.4.3", "@slorber/static-site-generator-webpack-plugin": "^4.0.7", "@svgr/webpack": "^6.2.1", "autoprefixer": "^10.4.7", @@ -15081,7 +15628,7 @@ "del": "^6.1.1", "detect-port": "^1.3.0", "escape-html": "^1.0.3", - "eta": "^1.12.3", + "eta": "^2.0.0", "file-loader": "^6.2.0", "fs-extra": "^10.1.0", "html-minifier-terser": "^6.1.0", @@ -15118,9 +15665,9 @@ } }, "@docusaurus/cssnano-preset": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/cssnano-preset/-/cssnano-preset-2.0.0-rc.1.tgz", - "integrity": "sha512-9/KmQvF+eTlMqUqG6UcXbRgxbGed/8bQInXuKEs+95/jI6jO/3xSzuRwuHHHP0naUvSVWjnNI9jngPrQerXE5w==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/cssnano-preset/-/cssnano-preset-2.4.3.tgz", + "integrity": "sha512-ZvGSRCi7z9wLnZrXNPG6DmVPHdKGd8dIn9pYbEOFiYihfv4uDR3UtxogmKf+rT8ZlKFf5Lqne8E8nt08zNM8CA==", "requires": { "cssnano-preset-advanced": "^5.3.8", "postcss": "^8.4.14", @@ -15129,23 +15676,23 @@ } }, "@docusaurus/logger": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/logger/-/logger-2.0.0-rc.1.tgz", - "integrity": "sha512-daa3g+SXuO9K60PVMiSUmDEK9Vro+Ed7i7uF8CH6QQJLcNZy/zJc0Xz62eH7ip1x77fmeb6Rg4Us1TqTFc9AbQ==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/logger/-/logger-2.4.3.tgz", + "integrity": "sha512-Zxws7r3yLufk9xM1zq9ged0YHs65mlRmtsobnFkdZTxWXdTYlWWLWdKyNKAsVC+D7zg+pv2fGbyabdOnyZOM3w==", "requires": { "chalk": "^4.1.2", "tslib": "^2.4.0" } }, "@docusaurus/mdx-loader": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/mdx-loader/-/mdx-loader-2.0.0-rc.1.tgz", - "integrity": "sha512-8Fg0c/ceu39knmr7w0dutm7gq3YxKYCqWVS2cB/cPATzChCCNH/AGLfBT6sz/Z4tjVXE+NyREq2pfOFvkhjVXg==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/mdx-loader/-/mdx-loader-2.4.3.tgz", + "integrity": "sha512-b1+fDnWtl3GiqkL0BRjYtc94FZrcDDBV1j8446+4tptB9BAOlePwG2p/pK6vGvfL53lkOsszXMghr2g67M0vCw==", "requires": { "@babel/parser": "^7.18.8", "@babel/traverse": "^7.18.8", - "@docusaurus/logger": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", + "@docusaurus/logger": "2.4.3", + "@docusaurus/utils": "2.4.3", "@mdx-js/mdx": "^1.6.22", "escape-html": "^1.0.3", "file-loader": "^6.2.0", @@ -15162,12 +15709,12 @@ } }, "@docusaurus/module-type-aliases": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/module-type-aliases/-/module-type-aliases-2.0.0-rc.1.tgz", - "integrity": "sha512-la7D8ggFP8I5nOp/Epl6NqTeDWcbofPVMOaVisRxQbx5iuF9Al+AITbaDgm4CXpFLJACsqhsXD5W4BnKX8ZxfA==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/module-type-aliases/-/module-type-aliases-2.4.3.tgz", + "integrity": "sha512-cwkBkt1UCiduuvEAo7XZY01dJfRn7UR/75mBgOdb1hKknhrabJZ8YH+7savd/y9kLExPyrhe0QwdS9GuzsRRIA==", "requires": { "@docusaurus/react-loadable": "5.5.2", - "@docusaurus/types": "2.0.0-rc.1", + "@docusaurus/types": "2.4.3", "@types/history": "^4.7.11", "@types/react": "*", "@types/react-router-config": "*", @@ -15177,17 +15724,17 @@ } }, "@docusaurus/plugin-content-blog": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-blog/-/plugin-content-blog-2.0.0-rc.1.tgz", - "integrity": "sha512-BVVrAGZujpjS/0rarY2o24rlylRRh2NZuM65kg0JNkkViF79SeEHsepog7IuHyoqGWPm1N/I7LpEp7k+gowZzQ==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-blog/-/plugin-content-blog-2.4.3.tgz", + "integrity": "sha512-PVhypqaA0t98zVDpOeTqWUTvRqCEjJubtfFUQ7zJNYdbYTbS/E/ytq6zbLVsN/dImvemtO/5JQgjLxsh8XLo8Q==", "requires": { - "@docusaurus/core": "2.0.0-rc.1", - "@docusaurus/logger": "2.0.0-rc.1", - "@docusaurus/mdx-loader": "2.0.0-rc.1", - "@docusaurus/types": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", - "@docusaurus/utils-common": "2.0.0-rc.1", - "@docusaurus/utils-validation": "2.0.0-rc.1", + "@docusaurus/core": "2.4.3", + "@docusaurus/logger": "2.4.3", + "@docusaurus/mdx-loader": "2.4.3", + "@docusaurus/types": "2.4.3", + "@docusaurus/utils": "2.4.3", + "@docusaurus/utils-common": "2.4.3", + "@docusaurus/utils-validation": "2.4.3", "cheerio": "^1.0.0-rc.12", "feed": "^4.2.2", "fs-extra": "^10.1.0", @@ -15200,17 +15747,17 @@ } }, "@docusaurus/plugin-content-docs": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-2.0.0-rc.1.tgz", - "integrity": "sha512-Yk5Hu6uaw3tRplzJnbDygwRhmZ3PCzEXD4SJpBA6cPC73ylfqOEh6qhiU+BWhMTtDXNhY+athk5Kycfk3DW1aQ==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-2.4.3.tgz", + "integrity": "sha512-N7Po2LSH6UejQhzTCsvuX5NOzlC+HiXOVvofnEPj0WhMu1etpLEXE6a4aTxrtg95lQ5kf0xUIdjX9sh3d3G76A==", "requires": { - "@docusaurus/core": "2.0.0-rc.1", - "@docusaurus/logger": "2.0.0-rc.1", - "@docusaurus/mdx-loader": "2.0.0-rc.1", - "@docusaurus/module-type-aliases": "2.0.0-rc.1", - "@docusaurus/types": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", - "@docusaurus/utils-validation": "2.0.0-rc.1", + "@docusaurus/core": "2.4.3", + "@docusaurus/logger": "2.4.3", + "@docusaurus/mdx-loader": "2.4.3", + "@docusaurus/module-type-aliases": "2.4.3", + "@docusaurus/types": "2.4.3", + "@docusaurus/utils": "2.4.3", + "@docusaurus/utils-validation": "2.4.3", "@types/react-router-config": "^5.0.6", "combine-promises": "^1.1.0", "fs-extra": "^10.1.0", @@ -15223,31 +15770,32 @@ } }, "@docusaurus/plugin-content-pages": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-pages/-/plugin-content-pages-2.0.0-rc.1.tgz", - "integrity": "sha512-FdO79WC5hfWDQu3/CTFLRQzTNc0e5n+HNzavm2MNkSzGV08BFJ6RAkbPbtra5CWef+6iXZav6D/tzv2jDPvLzA==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-pages/-/plugin-content-pages-2.4.3.tgz", + "integrity": "sha512-txtDVz7y3zGk67q0HjG0gRttVPodkHqE0bpJ+7dOaTH40CQFLSh7+aBeGnPOTl+oCPG+hxkim4SndqPqXjQ8Bg==", "requires": { - "@docusaurus/core": "2.0.0-rc.1", - "@docusaurus/mdx-loader": "2.0.0-rc.1", - "@docusaurus/types": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", - "@docusaurus/utils-validation": "2.0.0-rc.1", + "@docusaurus/core": "2.4.3", + "@docusaurus/mdx-loader": "2.4.3", + "@docusaurus/types": "2.4.3", + "@docusaurus/utils": "2.4.3", + "@docusaurus/utils-validation": "2.4.3", "fs-extra": "^10.1.0", "tslib": "^2.4.0", "webpack": "^5.73.0" } }, "@docusaurus/theme-common": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/theme-common/-/theme-common-2.0.0-rc.1.tgz", - "integrity": "sha512-1r9ZLKD9SeoCYVzWzcdR79Dia4ANlrlRjNl6uzETOEybjK6FF7yEa9Yra8EJcOCbi3coyYz5xFh/r1YHFTFHug==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/theme-common/-/theme-common-2.4.3.tgz", + "integrity": "sha512-7KaDJBXKBVGXw5WOVt84FtN8czGWhM0lbyWEZXGp8AFfL6sZQfRTluFp4QriR97qwzSyOfQb+nzcDZZU4tezUw==", "requires": { - "@docusaurus/mdx-loader": "2.0.0-rc.1", - "@docusaurus/module-type-aliases": "2.0.0-rc.1", - "@docusaurus/plugin-content-blog": "2.0.0-rc.1", - "@docusaurus/plugin-content-docs": "2.0.0-rc.1", - "@docusaurus/plugin-content-pages": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", + "@docusaurus/mdx-loader": "2.4.3", + "@docusaurus/module-type-aliases": "2.4.3", + "@docusaurus/plugin-content-blog": "2.4.3", + "@docusaurus/plugin-content-docs": "2.4.3", + "@docusaurus/plugin-content-pages": "2.4.3", + "@docusaurus/utils": "2.4.3", + "@docusaurus/utils-common": "2.4.3", "@types/history": "^4.7.11", "@types/react": "*", "@types/react-router-config": "*", @@ -15255,22 +15803,23 @@ "parse-numeric-range": "^1.3.0", "prism-react-renderer": "^1.3.5", "tslib": "^2.4.0", + "use-sync-external-store": "^1.2.0", "utility-types": "^3.10.0" } }, "@docusaurus/theme-translations": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/theme-translations/-/theme-translations-2.0.0-rc.1.tgz", - "integrity": "sha512-JLhNdlnbQhxVQzOnLyiCaTzKFa1lpVrM3nCrkGQKscoG2rY6ARGYMgMN2DkoH6hm7TflQ8+PE1S5MzzASeLs4Q==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/theme-translations/-/theme-translations-2.4.3.tgz", + "integrity": "sha512-H4D+lbZbjbKNS/Zw1Lel64PioUAIT3cLYYJLUf3KkuO/oc9e0QCVhIYVtUI2SfBCF2NNdlyhBDQEEMygsCedIg==", "requires": { "fs-extra": "^10.1.0", "tslib": "^2.4.0" } }, "@docusaurus/types": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/types/-/types-2.0.0-rc.1.tgz", - "integrity": "sha512-wX25FOZa/aKnCGA5ljWPaDpMW3TuTbs0BtjQ8WTC557p8zDvuz4r+g2/FPHsgWE0TKwUMf4usQU1m3XpJLPN+g==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/types/-/types-2.4.3.tgz", + "integrity": "sha512-W6zNLGQqfrp/EoPD0bhb9n7OobP+RHpmvVzpA+Z/IuU3Q63njJM24hmT0GYboovWcDtFmnIJC9wcyx4RVPQscw==", "requires": { "@types/history": "^4.7.11", "@types/react": "*", @@ -15283,12 +15832,13 @@ } }, "@docusaurus/utils": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/utils/-/utils-2.0.0-rc.1.tgz", - "integrity": "sha512-ym9I1OwIYbKs1LGaUajaA/vDG8VweJj/6YoZjHp+eDQHhTRIrHXiYoGDqorafRhftKwnA1EnyomuXpNd9bq8Gg==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/utils/-/utils-2.4.3.tgz", + "integrity": "sha512-fKcXsjrD86Smxv8Pt0TBFqYieZZCPh4cbf9oszUq/AMhZn3ujwpKaVYZACPX8mmjtYx0JOgNx52CREBfiGQB4A==", "requires": { - "@docusaurus/logger": "2.0.0-rc.1", + "@docusaurus/logger": "2.4.3", "@svgr/webpack": "^6.2.1", + "escape-string-regexp": "^4.0.0", "file-loader": "^6.2.0", "fs-extra": "^10.1.0", "github-slugger": "^1.4.0", @@ -15305,24 +15855,29 @@ } }, "@docusaurus/utils-common": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/utils-common/-/utils-common-2.0.0-rc.1.tgz", - "integrity": "sha512-+iZICpeFPZJ9oGJXuG92WTWee6WRnVx5BdzlcfuKf/f5KQX8PvwXR2tDME78FGGhShB8zr+vjuNEXuLvXT7j2A==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/utils-common/-/utils-common-2.4.3.tgz", + "integrity": "sha512-/jascp4GbLQCPVmcGkPzEQjNaAk3ADVfMtudk49Ggb+131B1WDD6HqlSmDf8MxGdy7Dja2gc+StHf01kiWoTDQ==", "requires": { "tslib": "^2.4.0" } }, "@docusaurus/utils-validation": { - "version": "2.0.0-rc.1", - "resolved": "https://registry.npmjs.org/@docusaurus/utils-validation/-/utils-validation-2.0.0-rc.1.tgz", - "integrity": "sha512-lj36gm9Ksu4tt/EUeLDWoMbXe3sfBxeIPIUUdqYcBYkF/rpQkh+uL/dncjNGiw6uvBOqXhOfsFVP045HtgShVw==", + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/@docusaurus/utils-validation/-/utils-validation-2.4.3.tgz", + "integrity": "sha512-G2+Vt3WR5E/9drAobP+hhZQMaswRwDlp6qOMi7o7ZypB+VO7N//DZWhZEwhcRGepMDJGQEwtPv7UxtYwPL9PBw==", "requires": { - "@docusaurus/logger": "2.0.0-rc.1", - "@docusaurus/utils": "2.0.0-rc.1", + "@docusaurus/logger": "2.4.3", + "@docusaurus/utils": "2.4.3", "joi": "^17.6.0", "js-yaml": "^4.1.0", "tslib": "^2.4.0" } + }, + "eta": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/eta/-/eta-2.2.0.tgz", + "integrity": "sha512-UVQ72Rqjy/ZKQalzV5dCCJP80GrmPrMxh6NlNf+erV6ObL0ZFkhCstWRawS85z3smdr3d2wXPsZEY7rDPfGd2g==" } } }, @@ -15428,6 +15983,27 @@ "@hapi/hoek": "^9.0.0" } }, + "@jest/schemas": { + "version": "29.6.3", + "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz", + "integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==", + "requires": { + "@sinclair/typebox": "^0.27.8" + } + }, + "@jest/types": { + "version": "29.6.3", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-29.6.3.tgz", + "integrity": "sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==", + "requires": { + "@jest/schemas": "^29.6.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + } + }, "@jridgewell/gen-mapping": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz", @@ -15448,18 +16024,18 @@ "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==" }, "@jridgewell/source-map": { - "version": "0.3.2", - "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz", - "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==", + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.5.tgz", + "integrity": "sha512-UTYAUj/wviwdsMfzoSJspJxbkH5o1snzwX0//0ENX1u/55kkZZkcTZP6u9bwKGkv+dkk9at4m1Cpt0uY80kcpQ==", "requires": { "@jridgewell/gen-mapping": "^0.3.0", "@jridgewell/trace-mapping": "^0.3.9" }, "dependencies": { "@jridgewell/gen-mapping": { - "version": "0.3.2", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz", - "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==", + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz", + "integrity": "sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==", "requires": { "@jridgewell/set-array": "^1.0.1", "@jridgewell/sourcemap-codec": "^1.4.10", @@ -15474,12 +16050,12 @@ "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==" }, "@jridgewell/trace-mapping": { - "version": "0.3.14", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.14.tgz", - "integrity": "sha512-bJWEfQ9lPTvm3SneWwRFVLzrh6nhjwqw7TUFFBEMzwvg7t7PCDenf2lDwqo4NQXzdpgBXyFgDWnQA+2vkruksQ==", + "version": "0.3.20", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.20.tgz", + "integrity": "sha512-R8LcPeWZol2zR8mmH3JeKQ6QRCFb7XgUhV9ZlGhHLGyg4wpPiPZNQOOWhFZhxKw8u//yTbNGI42Bx/3paXEQ+Q==", "requires": { - "@jridgewell/resolve-uri": "^3.0.3", - "@jridgewell/sourcemap-codec": "^1.4.10" + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" } }, "@leichtgewicht/ip-codec": { @@ -15544,10 +16120,20 @@ "@babel/helper-plugin-utils": "^7.10.4" } }, + "convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==" + }, + "is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==" + }, "semver": { - "version": "5.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", - "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==" + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", + "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==" }, "source-map": { "version": "0.5.7", @@ -15686,11 +16272,6 @@ "unicode-match-property-value-ecmascript": "^2.0.0" } }, - "regjsgen": { - "version": "0.5.2", - "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.2.tgz", - "integrity": "sha512-OFFT3MfrH90xIW8OOSyUrk6QHD5E9JOTeGodiJeBS3J6IwlgzJMNE/1bZklWz5oTg+9dCMyEetclvCVXOPoN3A==" - }, "regjsparser": { "version": "0.7.0", "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.7.0.tgz", @@ -15710,9 +16291,9 @@ } }, "@polka/url": { - "version": "1.0.0-next.21", - "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.21.tgz", - "integrity": "sha512-a5Sab1C4/icpTZVzZc5Ghpz88yQtGOyNqYXcZgOssB2uuAr+wF/MvN6bgtW32q7HHrvBki+BsZ0OuNv6EV3K9g==" + "version": "1.0.0-next.23", + "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.23.tgz", + "integrity": "sha512-C16M+IYz0rgRhWZdCmK+h58JMv8vijAA61gmz2rspCSwKwzBebpdcsiUmwrtJRdphuY30i6BSLEOP8ppbNLyLg==" }, "@sideway/address": { "version": "4.1.4", @@ -15732,6 +16313,11 @@ "resolved": "https://registry.npmjs.org/@sideway/pinpoint/-/pinpoint-2.0.0.tgz", "integrity": "sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ==" }, + "@sinclair/typebox": { + "version": "0.27.8", + "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz", + "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==" + }, "@sindresorhus/is": { "version": "0.14.0", "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.14.0.tgz", @@ -15748,121 +16334,123 @@ } }, "@svgr/babel-plugin-add-jsx-attribute": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-6.0.0.tgz", - "integrity": "sha512-MdPdhdWLtQsjd29Wa4pABdhWbaRMACdM1h31BY+c6FghTZqNGT7pEYdBoaGeKtdTOBC/XNFQaKVj+r/Ei2ryWA==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-6.5.1.tgz", + "integrity": "sha512-9PYGcXrAxitycIjRmZB+Q0JaN07GZIWaTBIGQzfaZv+qr1n8X1XUEJ5rZ/vx6OVD9RRYlrNnXWExQXcmZeD/BQ==", "requires": {} }, "@svgr/babel-plugin-remove-jsx-attribute": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-6.0.0.tgz", - "integrity": "sha512-aVdtfx9jlaaxc3unA6l+M9YRnKIZjOhQPthLKqmTXC8UVkBLDRGwPKo+r8n3VZN8B34+yVajzPTZ+ptTSuZZCw==", + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-8.0.0.tgz", + "integrity": "sha512-BcCkm/STipKvbCl6b7QFrMh/vx00vIP63k2eM66MfHJzPr6O2U0jYEViXkHJWqXqQYjdeA9cuCl5KWmlwjDvbA==", "requires": {} }, "@svgr/babel-plugin-remove-jsx-empty-expression": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-6.0.0.tgz", - "integrity": "sha512-Ccj42ApsePD451AZJJf1QzTD1B/BOU392URJTeXFxSK709i0KUsGtbwyiqsKu7vsYxpTM0IA5clAKDyf9RCZyA==", + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-8.0.0.tgz", + "integrity": "sha512-5BcGCBfBxB5+XSDSWnhTThfI9jcO5f0Ai2V24gZpG+wXF14BzwxxdDb4g6trdOux0rhibGs385BeFMSmxtS3uA==", "requires": {} }, "@svgr/babel-plugin-replace-jsx-attribute-value": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-6.0.0.tgz", - "integrity": "sha512-88V26WGyt1Sfd1emBYmBJRWMmgarrExpKNVmI9vVozha4kqs6FzQJ/Kp5+EYli1apgX44518/0+t9+NU36lThQ==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-6.5.1.tgz", + "integrity": "sha512-8DPaVVE3fd5JKuIC29dqyMB54sA6mfgki2H2+swh+zNJoynC8pMPzOkidqHOSc6Wj032fhl8Z0TVn1GiPpAiJg==", "requires": {} }, "@svgr/babel-plugin-svg-dynamic-title": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-6.0.0.tgz", - "integrity": "sha512-F7YXNLfGze+xv0KMQxrl2vkNbI9kzT9oDK55/kUuymh1ACyXkMV+VZWX1zEhSTfEKh7VkHVZGmVtHg8eTZ6PRg==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-6.5.1.tgz", + "integrity": "sha512-FwOEi0Il72iAzlkaHrlemVurgSQRDFbk0OC8dSvD5fSBPHltNh7JtLsxmZUhjYBZo2PpcU/RJvvi6Q0l7O7ogw==", "requires": {} }, "@svgr/babel-plugin-svg-em-dimensions": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-6.0.0.tgz", - "integrity": "sha512-+rghFXxdIqJNLQK08kwPBD3Z22/0b2tEZ9lKiL/yTfuyj1wW8HUXu4bo/XkogATIYuXSghVQOOCwURXzHGKyZA==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-6.5.1.tgz", + "integrity": "sha512-gWGsiwjb4tw+ITOJ86ndY/DZZ6cuXMNE/SjcDRg+HLuCmwpcjOktwRF9WgAiycTqJD/QXqL2f8IzE2Rzh7aVXA==", "requires": {} }, "@svgr/babel-plugin-transform-react-native-svg": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-6.0.0.tgz", - "integrity": "sha512-VaphyHZ+xIKv5v0K0HCzyfAaLhPGJXSk2HkpYfXIOKb7DjLBv0soHDxNv6X0vr2titsxE7klb++u7iOf7TSrFQ==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-6.5.1.tgz", + "integrity": "sha512-2jT3nTayyYP7kI6aGutkyfJ7UMGtuguD72OjeGLwVNyfPRBD8zQthlvL+fAbAKk5n9ZNcvFkp/b1lZ7VsYqVJg==", "requires": {} }, "@svgr/babel-plugin-transform-svg-component": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-6.2.0.tgz", - "integrity": "sha512-bhYIpsORb++wpsp91fymbFkf09Z/YEKR0DnFjxvN+8JHeCUD2unnh18jIMKnDJTWtvpTaGYPXELVe4OOzFI0xg==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-6.5.1.tgz", + "integrity": "sha512-a1p6LF5Jt33O3rZoVRBqdxL350oge54iZWHNI6LJB5tQ7EelvD/Mb1mfBiZNAan0dt4i3VArkFRjA4iObuNykQ==", "requires": {} }, "@svgr/babel-preset": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/@svgr/babel-preset/-/babel-preset-6.2.0.tgz", - "integrity": "sha512-4WQNY0J71JIaL03DRn0vLiz87JXx0b9dYm2aA8XHlQJQoixMl4r/soYHm8dsaJZ3jWtkCiOYy48dp9izvXhDkQ==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-preset/-/babel-preset-6.5.1.tgz", + "integrity": "sha512-6127fvO/FF2oi5EzSQOAjo1LE3OtNVh11R+/8FXa+mHx1ptAaS4cknIjnUA7e6j6fwGGJ17NzaTJFUwOV2zwCw==", "requires": { - "@svgr/babel-plugin-add-jsx-attribute": "^6.0.0", - "@svgr/babel-plugin-remove-jsx-attribute": "^6.0.0", - "@svgr/babel-plugin-remove-jsx-empty-expression": "^6.0.0", - "@svgr/babel-plugin-replace-jsx-attribute-value": "^6.0.0", - "@svgr/babel-plugin-svg-dynamic-title": "^6.0.0", - "@svgr/babel-plugin-svg-em-dimensions": "^6.0.0", - "@svgr/babel-plugin-transform-react-native-svg": "^6.0.0", - "@svgr/babel-plugin-transform-svg-component": "^6.2.0" + "@svgr/babel-plugin-add-jsx-attribute": "^6.5.1", + "@svgr/babel-plugin-remove-jsx-attribute": "*", + "@svgr/babel-plugin-remove-jsx-empty-expression": "*", + "@svgr/babel-plugin-replace-jsx-attribute-value": "^6.5.1", + "@svgr/babel-plugin-svg-dynamic-title": "^6.5.1", + "@svgr/babel-plugin-svg-em-dimensions": "^6.5.1", + "@svgr/babel-plugin-transform-react-native-svg": "^6.5.1", + "@svgr/babel-plugin-transform-svg-component": "^6.5.1" } }, "@svgr/core": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/@svgr/core/-/core-6.2.1.tgz", - "integrity": "sha512-NWufjGI2WUyrg46mKuySfviEJ6IxHUOm/8a3Ph38VCWSp+83HBraCQrpEM3F3dB6LBs5x8OElS8h3C0oOJaJAA==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/core/-/core-6.5.1.tgz", + "integrity": "sha512-/xdLSWxK5QkqG524ONSjvg3V/FkNyCv538OIBdQqPNaAta3AsXj/Bd2FbvR87yMbXO2hFSWiAe/Q6IkVPDw+mw==", "requires": { - "@svgr/plugin-jsx": "^6.2.1", + "@babel/core": "^7.19.6", + "@svgr/babel-preset": "^6.5.1", + "@svgr/plugin-jsx": "^6.5.1", "camelcase": "^6.2.0", "cosmiconfig": "^7.0.1" } }, "@svgr/hast-util-to-babel-ast": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-6.2.1.tgz", - "integrity": "sha512-pt7MMkQFDlWJVy9ULJ1h+hZBDGFfSCwlBNW1HkLnVi7jUhyEXUaGYWi1x6bM2IXuAR9l265khBT4Av4lPmaNLQ==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-6.5.1.tgz", + "integrity": "sha512-1hnUxxjd83EAxbL4a0JDJoD3Dao3hmjvyvyEV8PzWmLK3B9m9NPlW7GKjFyoWE8nM7HnXzPcmmSyOW8yOddSXw==", "requires": { - "@babel/types": "^7.15.6", - "entities": "^3.0.1" + "@babel/types": "^7.20.0", + "entities": "^4.4.0" } }, "@svgr/plugin-jsx": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/@svgr/plugin-jsx/-/plugin-jsx-6.2.1.tgz", - "integrity": "sha512-u+MpjTsLaKo6r3pHeeSVsh9hmGRag2L7VzApWIaS8imNguqoUwDq/u6U/NDmYs/KAsrmtBjOEaAAPbwNGXXp1g==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/plugin-jsx/-/plugin-jsx-6.5.1.tgz", + "integrity": "sha512-+UdQxI3jgtSjCykNSlEMuy1jSRQlGC7pqBCPvkG/2dATdWo082zHTTK3uhnAju2/6XpE6B5mZ3z4Z8Ns01S8Gw==", "requires": { - "@babel/core": "^7.15.5", - "@svgr/babel-preset": "^6.2.0", - "@svgr/hast-util-to-babel-ast": "^6.2.1", - "svg-parser": "^2.0.2" + "@babel/core": "^7.19.6", + "@svgr/babel-preset": "^6.5.1", + "@svgr/hast-util-to-babel-ast": "^6.5.1", + "svg-parser": "^2.0.4" } }, "@svgr/plugin-svgo": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/@svgr/plugin-svgo/-/plugin-svgo-6.2.0.tgz", - "integrity": "sha512-oDdMQONKOJEbuKwuy4Np6VdV6qoaLLvoY86hjvQEgU82Vx1MSWRyYms6Sl0f+NtqxLI/rDVufATbP/ev996k3Q==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/plugin-svgo/-/plugin-svgo-6.5.1.tgz", + "integrity": "sha512-omvZKf8ixP9z6GWgwbtmP9qQMPX4ODXi+wzbVZgomNFsUIlHA1sf4fThdwTWSsZGgvGAG6yE+b/F5gWUkcZ/iQ==", "requires": { "cosmiconfig": "^7.0.1", "deepmerge": "^4.2.2", - "svgo": "^2.5.0" + "svgo": "^2.8.0" } }, "@svgr/webpack": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/@svgr/webpack/-/webpack-6.2.1.tgz", - "integrity": "sha512-h09ngMNd13hnePwgXa+Y5CgOjzlCvfWLHg+MBnydEedAnuLRzUHUJmGS3o2OsrhxTOOqEsPOFt5v/f6C5Qulcw==", + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/@svgr/webpack/-/webpack-6.5.1.tgz", + "integrity": "sha512-cQ/AsnBkXPkEK8cLbv4Dm7JGXq2XrumKnL1dRpJD9rIO2fTIlJI9a1uCciYG1F2aUsox/hJQyNGbt3soDxSRkA==", "requires": { - "@babel/core": "^7.15.5", - "@babel/plugin-transform-react-constant-elements": "^7.14.5", - "@babel/preset-env": "^7.15.6", - "@babel/preset-react": "^7.14.5", - "@babel/preset-typescript": "^7.15.0", - "@svgr/core": "^6.2.1", - "@svgr/plugin-jsx": "^6.2.1", - "@svgr/plugin-svgo": "^6.2.0" + "@babel/core": "^7.19.6", + "@babel/plugin-transform-react-constant-elements": "^7.18.12", + "@babel/preset-env": "^7.19.4", + "@babel/preset-react": "^7.18.6", + "@babel/preset-typescript": "^7.18.6", + "@svgr/core": "^6.5.1", + "@svgr/plugin-jsx": "^6.5.1", + "@svgr/plugin-svgo": "^6.5.1" } }, "@szmarczak/http-timer": { @@ -15879,89 +16467,72 @@ "integrity": "sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==" }, "@types/body-parser": { - "version": "1.19.2", - "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.2.tgz", - "integrity": "sha512-ALYone6pm6QmwZoAgeyNksccT9Q4AWZQ6PvfwR37GT6r6FWUPguq6sUmNGSMV2Wr761oQoBxwGGa6DR5o1DC9g==", + "version": "1.19.5", + "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz", + "integrity": "sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==", "requires": { "@types/connect": "*", "@types/node": "*" } }, "@types/bonjour": { - "version": "3.5.10", - "resolved": "https://registry.npmjs.org/@types/bonjour/-/bonjour-3.5.10.tgz", - "integrity": "sha512-p7ienRMiS41Nu2/igbJxxLDWrSZ0WxM8UQgCeO9KhoVF7cOVFkrKsiDr1EsJIla8vV3oEEjGcz11jc5yimhzZw==", + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@types/bonjour/-/bonjour-3.5.13.tgz", + "integrity": "sha512-z9fJ5Im06zvUL548KvYNecEVlA7cVDkGUi6kZusb04mpyEFKCIZJvloCcmpmLaIahDpOQGHaHmG6imtPMmPXGQ==", "requires": { "@types/node": "*" } }, "@types/connect": { - "version": "3.4.35", - "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.35.tgz", - "integrity": "sha512-cdeYyv4KWoEgpBISTxWvqYsVy444DOqehiF3fM3ne10AmJ62RSyNkUnxMJXHQWRQQX2eR94m5y1IZyDwBjV9FQ==", + "version": "3.4.38", + "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz", + "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==", "requires": { "@types/node": "*" } }, "@types/connect-history-api-fallback": { - "version": "1.3.5", - "resolved": "https://registry.npmjs.org/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.3.5.tgz", - "integrity": "sha512-h8QJa8xSb1WD4fpKBDcATDNGXghFj6/3GRWG6dhmRcu0RX1Ubasur2Uvx5aeEwlf0MwblEC2bMzzMQntxnw/Cw==", + "version": "1.5.3", + "resolved": "https://registry.npmjs.org/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.5.3.tgz", + "integrity": "sha512-6mfQ6iNvhSKCZJoY6sIG3m0pKkdUcweVNOLuBBKvoWGzl2yRxOJcYOTRyLKt3nxXvBLJWa6QkW//tgbIwJehmA==", "requires": { "@types/express-serve-static-core": "*", "@types/node": "*" } }, - "@types/eslint": { - "version": "8.4.5", - "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.4.5.tgz", - "integrity": "sha512-dhsC09y1gpJWnK+Ff4SGvCuSnk9DaU0BJZSzOwa6GVSg65XtTugLBITDAAzRU5duGBoXBHpdR/9jHGxJjNflJQ==", - "requires": { - "@types/estree": "*", - "@types/json-schema": "*" - } - }, - "@types/eslint-scope": { - "version": "3.7.4", - "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.4.tgz", - "integrity": "sha512-9K4zoImiZc3HlIp6AVUDE4CWYx22a+lhSZMYNpbjW04+YF0KWj4pJXnEMjdnFTiQibFFmElcsasJXDbdI/EPhA==", - "requires": { - "@types/eslint": "*", - "@types/estree": "*" - } - }, "@types/estree": { - "version": "0.0.51", - "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.51.tgz", - "integrity": "sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==" + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz", + "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==" }, "@types/express": { - "version": "4.17.13", - "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.13.tgz", - "integrity": "sha512-6bSZTPaTIACxn48l50SR+axgrqm6qXFIxrdAKaG6PaJk3+zuUr35hBlgT7vOmJcum+OEaIBLtHV/qloEAFITeA==", + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.21.tgz", + "integrity": "sha512-ejlPM315qwLpaQlQDTjPdsUFSc6ZsP4AN6AlWnogPjQ7CVi7PYF3YVz+CY3jE2pwYf7E/7HlDAN0rV2GxTG0HQ==", "requires": { "@types/body-parser": "*", - "@types/express-serve-static-core": "^4.17.18", + "@types/express-serve-static-core": "^4.17.33", "@types/qs": "*", "@types/serve-static": "*" } }, "@types/express-serve-static-core": { - "version": "4.17.29", - "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.17.29.tgz", - "integrity": "sha512-uMd++6dMKS32EOuw1Uli3e3BPgdLIXmezcfHv7N4c1s3gkhikBplORPpMq3fuWkxncZN1reb16d5n8yhQ80x7Q==", + "version": "4.17.41", + "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.17.41.tgz", + "integrity": "sha512-OaJ7XLaelTgrvlZD8/aa0vvvxZdUmlCn6MtWeB7TkiKW70BQLc9XEPpDLPdbo52ZhXUCrznlWdCHWxJWtdyajA==", "requires": { "@types/node": "*", "@types/qs": "*", - "@types/range-parser": "*" + "@types/range-parser": "*", + "@types/send": "*" } }, "@types/hast": { - "version": "2.3.4", - "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.4.tgz", - "integrity": "sha512-wLEm0QvaoawEDoTRwzTXp4b4jpwiJDvR5KMnFnVodm3scufTlBOWRD6N1OBf9TZMhjlNsSfcO5V+7AF4+Vy+9g==", + "version": "2.3.10", + "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.10.tgz", + "integrity": "sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw==", "requires": { - "@types/unist": "*" + "@types/unist": "^2" } }, "@types/history": { @@ -15974,37 +16545,71 @@ "resolved": "https://registry.npmjs.org/@types/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz", "integrity": "sha512-oh/6byDPnL1zeNXFrDXFLyZjkr1MsBG667IM792caf1L2UPOOMf65NFzjUH/ltyfwjAGfs1rsX1eftK0jC/KIg==" }, + "@types/http-errors": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz", + "integrity": "sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==" + }, "@types/http-proxy": { - "version": "1.17.9", - "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.9.tgz", - "integrity": "sha512-QsbSjA/fSk7xB+UXlCT3wHBy5ai9wOcNDWwZAtud+jXhwOM3l+EYZh8Lng4+/6n8uar0J7xILzqftJdJ/Wdfkw==", + "version": "1.17.14", + "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.14.tgz", + "integrity": "sha512-SSrD0c1OQzlFX7pGu1eXxSEjemej64aaNPRhhVYUGqXh0BtldAAx37MG8btcumvpgKyZp1F5Gn3JkktdxiFv6w==", "requires": { "@types/node": "*" } }, + "@types/istanbul-lib-coverage": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz", + "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==" + }, + "@types/istanbul-lib-report": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz", + "integrity": "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==", + "requires": { + "@types/istanbul-lib-coverage": "*" + } + }, + "@types/istanbul-reports": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz", + "integrity": "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==", + "requires": { + "@types/istanbul-lib-report": "*" + } + }, "@types/json-schema": { "version": "7.0.11", "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.11.tgz", "integrity": "sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==" }, "@types/mdast": { - "version": "3.0.10", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.10.tgz", - "integrity": "sha512-W864tg/Osz1+9f4lrGTZpCSO5/z4608eUp19tbozkq2HJK6i3z1kT0H9tlADXuYIb1YYOBByU4Jsqkk75q48qA==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", "requires": { - "@types/unist": "*" + "@types/unist": "^2" } }, "@types/mime": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.2.tgz", - "integrity": "sha512-YATxVxgRqNH6nHEIsvg6k2Boc1JHI9ZbH5iWFFv/MTkchz3b1ieGDa5T0a9RznNdI0KhVbdbWSN+KWWrQZRxTw==" + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz", + "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==" }, "@types/node": { "version": "18.0.6", "resolved": "https://registry.npmjs.org/@types/node/-/node-18.0.6.tgz", "integrity": "sha512-/xUq6H2aQm261exT6iZTMifUySEt4GR5KX8eYyY+C4MSNPqSh9oNIP7tz2GLKTlFaiBbgZNxffoR3CVRG+cljw==" }, + "@types/node-forge": { + "version": "1.3.9", + "resolved": "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.3.9.tgz", + "integrity": "sha512-meK88cx/sTalPSLSoCzkiUB4VPIFHmxtXm5FaaqRDqBX2i/Sy8bJ4odsan0b20RBjPh06dAQ+OTTdnyQyhJZyQ==", + "requires": { + "@types/node": "*" + } + }, "@types/parse-json": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.0.tgz", @@ -16021,14 +16626,14 @@ "integrity": "sha512-JCB8C6SnDoQf0cNycqd/35A7MjcnK+ZTqE7judS6o7utxUCg6imJg3QK2qzHKszlTjcj2cn+NwMB2i96ubpj7w==" }, "@types/qs": { - "version": "6.9.7", - "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.7.tgz", - "integrity": "sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw==" + "version": "6.9.10", + "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.10.tgz", + "integrity": "sha512-3Gnx08Ns1sEoCrWssEgTSJs/rsT2vhGP+Ja9cnnk9k4ALxinORlQneLXFeFKOTJMOeZUFD1s7w+w2AphTpvzZw==" }, "@types/range-parser": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.4.tgz", - "integrity": "sha512-EEhsLsD6UsDM1yFhAvy0Cjr6VwmpMWqFBCb9w07wVugF7w9nfajxLuVmngTIpgS6svCnm6Vaw+MZhoDCKnOfsw==" + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz", + "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==" }, "@types/react": { "version": "18.0.15", @@ -16050,13 +16655,13 @@ } }, "@types/react-router-config": { - "version": "5.0.6", - "resolved": "https://registry.npmjs.org/@types/react-router-config/-/react-router-config-5.0.6.tgz", - "integrity": "sha512-db1mx37a1EJDf1XeX8jJN7R3PZABmJQXR8r28yUjVMFSjkmnQo6X6pOEEmNl+Tp2gYQOGPdYbFIipBtdElZ3Yg==", + "version": "5.0.10", + "resolved": "https://registry.npmjs.org/@types/react-router-config/-/react-router-config-5.0.10.tgz", + "integrity": "sha512-Wn6c/tXdEgi9adCMtDwx8Q2vGty6TsPTc/wCQQ9kAlye8UqFxj0vGFWWuhywNfkwqth+SOgJxQTLTZukrqDQmQ==", "requires": { "@types/history": "^4.7.11", "@types/react": "*", - "@types/react-router": "*" + "@types/react-router": "^5.1.0" } }, "@types/react-router-dom": { @@ -16075,9 +16680,9 @@ "integrity": "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==" }, "@types/sax": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/@types/sax/-/sax-1.2.4.tgz", - "integrity": "sha512-pSAff4IAxJjfAXUG6tFkO7dsSbTmf8CtUpfhhZ5VhkRpC4628tJhh3+V6H1E+/Gs9piSzYKT5yzHO5M4GG9jkw==", + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/@types/sax/-/sax-1.2.7.tgz", + "integrity": "sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A==", "requires": { "@types/node": "*" } @@ -16087,27 +16692,37 @@ "resolved": "https://registry.npmjs.org/@types/scheduler/-/scheduler-0.16.2.tgz", "integrity": "sha512-hppQEBDmlwhFAXKJX2KnWLYu5yMfi91yazPb2l+lbJiwW+wdo1gNeRA+3RgNSO39WYX2euey41KEwnqesU2Jew==" }, + "@types/send": { + "version": "0.17.4", + "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.4.tgz", + "integrity": "sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==", + "requires": { + "@types/mime": "^1", + "@types/node": "*" + } + }, "@types/serve-index": { - "version": "1.9.1", - "resolved": "https://registry.npmjs.org/@types/serve-index/-/serve-index-1.9.1.tgz", - "integrity": "sha512-d/Hs3nWDxNL2xAczmOVZNj92YZCS6RGxfBPjKzuu/XirCgXdpKEb88dYNbrYGint6IVWLNP+yonwVAuRC0T2Dg==", + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@types/serve-index/-/serve-index-1.9.4.tgz", + "integrity": "sha512-qLpGZ/c2fhSs5gnYsQxtDEq3Oy8SXPClIXkW5ghvAvsNuVSA8k+gCONcUCS/UjLEYvYps+e8uBtfgXgvhwfNug==", "requires": { "@types/express": "*" } }, "@types/serve-static": { - "version": "1.13.10", - "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.13.10.tgz", - "integrity": "sha512-nCkHGI4w7ZgAdNkrEu0bv+4xNV/XDqW+DydknebMOQwkpDGx8G+HTlj7R7ABI8i8nKxVw0wtKPi1D+lPOkh4YQ==", + "version": "1.15.5", + "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.5.tgz", + "integrity": "sha512-PDRk21MnK70hja/YF8AHfC7yIsiQHn1rcXx7ijCFBX/k+XQJhQT/gw3xekXKJvx+5SXaMMS8oqQy09Mzvz2TuQ==", "requires": { - "@types/mime": "^1", + "@types/http-errors": "*", + "@types/mime": "*", "@types/node": "*" } }, "@types/sockjs": { - "version": "0.3.33", - "resolved": "https://registry.npmjs.org/@types/sockjs/-/sockjs-0.3.33.tgz", - "integrity": "sha512-f0KEEe05NvUnat+boPTZ0dgaLZ4SfSouXUgv5noUiefG2ajgKjmETo9ZJyuqsl7dfl2aHlLJUiki6B4ZYldiiw==", + "version": "0.3.36", + "resolved": "https://registry.npmjs.org/@types/sockjs/-/sockjs-0.3.36.tgz", + "integrity": "sha512-MK9V6NzAS1+Ud7JV9lJLFqW85VbC9dq3LmwZCuBe4wBDgKC0Kj/jd8Xl+nSviU+Qc3+m7umHHyHg//2KSa0a0Q==", "requires": { "@types/node": "*" } @@ -16118,141 +16733,154 @@ "integrity": "sha512-PBjIUxZHOuj0R15/xuwJYjFi+KZdNFrehocChv4g5hu6aFroHue8m0lBP0POdK2nKzbw0cgV1mws8+V/JAcEkQ==" }, "@types/ws": { - "version": "8.5.3", - "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.5.3.tgz", - "integrity": "sha512-6YOoWjruKj1uLf3INHH7D3qTXwFfEsg1kf3c0uDdSBJwfa/llkwIjrAGV7j7mVgGNbzTQ3HiHKKDXl6bJPD97w==", + "version": "8.5.9", + "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.5.9.tgz", + "integrity": "sha512-jbdrY0a8lxfdTp/+r7Z4CkycbOFN8WX+IOchLJr3juT/xzbJ8URyTVSJ/hvNdadTgM1mnedb47n+Y31GsFnQlg==", "requires": { "@types/node": "*" } }, + "@types/yargs": { + "version": "17.0.31", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.31.tgz", + "integrity": "sha512-bocYSx4DI8TmdlvxqGpVNXOgCNR1Jj0gNPhhAY+iz1rgKDAaYrAYdFYnhDV1IFuiuVc9HkOwyDcFxaTElF3/wg==", + "requires": { + "@types/yargs-parser": "*" + } + }, + "@types/yargs-parser": { + "version": "21.0.3", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz", + "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==" + }, "@webassemblyjs/ast": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.11.1.tgz", - "integrity": "sha512-ukBh14qFLjxTQNTXocdyksN5QdM28S1CxHt2rdskFyL+xFV7VremuBLVbmCePj+URalXBENx/9Lm7lnhihtCSw==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz", + "integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==", "requires": { - "@webassemblyjs/helper-numbers": "1.11.1", - "@webassemblyjs/helper-wasm-bytecode": "1.11.1" + "@webassemblyjs/helper-numbers": "1.11.6", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6" } }, "@webassemblyjs/floating-point-hex-parser": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.1.tgz", - "integrity": "sha512-iGRfyc5Bq+NnNuX8b5hwBrRjzf0ocrJPI6GWFodBFzmFnyvrQ83SHKhmilCU/8Jv67i4GJZBMhEzltxzcNagtQ==" + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz", + "integrity": "sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==" }, "@webassemblyjs/helper-api-error": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.1.tgz", - "integrity": "sha512-RlhS8CBCXfRUR/cwo2ho9bkheSXG0+NwooXcc3PAILALf2QLdFyj7KGsKRbVc95hZnhnERon4kW/D3SZpp6Tcg==" + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz", + "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==" }, "@webassemblyjs/helper-buffer": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.1.tgz", - "integrity": "sha512-gwikF65aDNeeXa8JxXa2BAk+REjSyhrNC9ZwdT0f8jc4dQQeDQ7G4m0f2QCLPJiMTTO6wfDmRmj/pW0PsUvIcA==" + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz", + "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw==" }, "@webassemblyjs/helper-numbers": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.1.tgz", - "integrity": "sha512-vDkbxiB8zfnPdNK9Rajcey5C0w+QJugEglN0of+kmO8l7lDb77AnlKYQF7aarZuCrv+l0UvqL+68gSDr3k9LPQ==", + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz", + "integrity": "sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==", "requires": { - "@webassemblyjs/floating-point-hex-parser": "1.11.1", - "@webassemblyjs/helper-api-error": "1.11.1", + "@webassemblyjs/floating-point-hex-parser": "1.11.6", + "@webassemblyjs/helper-api-error": "1.11.6", "@xtuc/long": "4.2.2" } }, "@webassemblyjs/helper-wasm-bytecode": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.1.tgz", - "integrity": "sha512-PvpoOGiJwXeTrSf/qfudJhwlvDQxFgelbMqtq52WWiXC6Xgg1IREdngmPN3bs4RoO83PnL/nFrxucXj1+BX62Q==" + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz", + "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==" }, "@webassemblyjs/helper-wasm-section": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.1.tgz", - "integrity": "sha512-10P9No29rYX1j7F3EVPX3JvGPQPae+AomuSTPiF9eBQeChHI6iqjMIwR9JmOJXwpnn/oVGDk7I5IlskuMwU/pg==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz", + "integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==", "requires": { - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/helper-buffer": "1.11.1", - "@webassemblyjs/helper-wasm-bytecode": "1.11.1", - "@webassemblyjs/wasm-gen": "1.11.1" + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/wasm-gen": "1.12.1" } }, "@webassemblyjs/ieee754": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.1.tgz", - "integrity": "sha512-hJ87QIPtAMKbFq6CGTkZYJivEwZDbQUgYd3qKSadTNOhVY7p+gfP6Sr0lLRVTaG1JjFj+r3YchoqRYxNH3M0GQ==", + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz", + "integrity": "sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==", "requires": { "@xtuc/ieee754": "^1.2.0" } }, "@webassemblyjs/leb128": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.1.tgz", - "integrity": "sha512-BJ2P0hNZ0u+Th1YZXJpzW6miwqQUGcIHT1G/sf72gLVD9DZ5AdYTqPNbHZh6K1M5VmKvFXwGSWZADz+qBWxeRw==", + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.6.tgz", + "integrity": "sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==", "requires": { "@xtuc/long": "4.2.2" } }, "@webassemblyjs/utf8": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.1.tgz", - "integrity": "sha512-9kqcxAEdMhiwQkHpkNiorZzqpGrodQQ2IGrHHxCy+Ozng0ofyMA0lTqiLkVs1uzTRejX+/O0EOT7KxqVPuXosQ==" + "version": "1.11.6", + "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.6.tgz", + "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==" }, "@webassemblyjs/wasm-edit": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.1.tgz", - "integrity": "sha512-g+RsupUC1aTHfR8CDgnsVRVZFJqdkFHpsHMfJuWQzWU3tvnLC07UqHICfP+4XyL2tnr1amvl1Sdp06TnYCmVkA==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz", + "integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==", "requires": { - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/helper-buffer": "1.11.1", - "@webassemblyjs/helper-wasm-bytecode": "1.11.1", - "@webassemblyjs/helper-wasm-section": "1.11.1", - "@webassemblyjs/wasm-gen": "1.11.1", - "@webassemblyjs/wasm-opt": "1.11.1", - "@webassemblyjs/wasm-parser": "1.11.1", - "@webassemblyjs/wast-printer": "1.11.1" + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/helper-wasm-section": "1.12.1", + "@webassemblyjs/wasm-gen": "1.12.1", + "@webassemblyjs/wasm-opt": "1.12.1", + "@webassemblyjs/wasm-parser": "1.12.1", + "@webassemblyjs/wast-printer": "1.12.1" } }, "@webassemblyjs/wasm-gen": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.1.tgz", - "integrity": "sha512-F7QqKXwwNlMmsulj6+O7r4mmtAlCWfO/0HdgOxSklZfQcDu0TpLiD1mRt/zF25Bk59FIjEuGAIyn5ei4yMfLhA==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz", + "integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==", "requires": { - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/helper-wasm-bytecode": "1.11.1", - "@webassemblyjs/ieee754": "1.11.1", - "@webassemblyjs/leb128": "1.11.1", - "@webassemblyjs/utf8": "1.11.1" + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/ieee754": "1.11.6", + "@webassemblyjs/leb128": "1.11.6", + "@webassemblyjs/utf8": "1.11.6" } }, "@webassemblyjs/wasm-opt": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.1.tgz", - "integrity": "sha512-VqnkNqnZlU5EB64pp1l7hdm3hmQw7Vgqa0KF/KCNO9sIpI6Fk6brDEiX+iCOYrvMuBWDws0NkTOxYEb85XQHHw==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz", + "integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==", "requires": { - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/helper-buffer": "1.11.1", - "@webassemblyjs/wasm-gen": "1.11.1", - "@webassemblyjs/wasm-parser": "1.11.1" + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/wasm-gen": "1.12.1", + "@webassemblyjs/wasm-parser": "1.12.1" } }, "@webassemblyjs/wasm-parser": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.1.tgz", - "integrity": "sha512-rrBujw+dJu32gYB7/Lup6UhdkPx9S9SnobZzRVL7VcBH9Bt9bCBLEuX/YXOOtBsOZ4NQrRykKhffRWHvigQvOA==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz", + "integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==", "requires": { - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/helper-api-error": "1.11.1", - "@webassemblyjs/helper-wasm-bytecode": "1.11.1", - "@webassemblyjs/ieee754": "1.11.1", - "@webassemblyjs/leb128": "1.11.1", - "@webassemblyjs/utf8": "1.11.1" + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-api-error": "1.11.6", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/ieee754": "1.11.6", + "@webassemblyjs/leb128": "1.11.6", + "@webassemblyjs/utf8": "1.11.6" } }, "@webassemblyjs/wast-printer": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.11.1.tgz", - "integrity": "sha512-IQboUWM4eKzWW+N/jij2sRatKMh99QEelo3Eb2q0qXkvPRISAj8Qxtmw5itwqK+TTkBuUIE45AxYPToqPtL5gg==", + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz", + "integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==", "requires": { - "@webassemblyjs/ast": "1.11.1", + "@webassemblyjs/ast": "1.12.1", "@xtuc/long": "4.2.2" } }, @@ -16314,9 +16942,9 @@ "requires": {} }, "acorn-walk": { - "version": "8.2.0", - "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz", - "integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==" + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.0.tgz", + "integrity": "sha512-FS7hV565M5l1R08MXqo8odwMTB02C2UqzB17RVgu9EyuYFBqJZ3/ZY97sQD5FewVu1UyDFc1yztUDrAwT0EypA==" }, "address": { "version": "1.2.0", @@ -16376,30 +17004,31 @@ "requires": {} }, "algoliasearch": { - "version": "4.14.0", - "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-4.14.0.tgz", - "integrity": "sha512-r1rt5UQnrmqwjloi4tZzggUC7oWjNR/gfk+fjx0x4oP2UeDW5c8/XCovVFs9nwJ4n2xNKlxELyMAedcuLrBdng==", - "requires": { - "@algolia/cache-browser-local-storage": "4.14.0", - "@algolia/cache-common": "4.14.0", - "@algolia/cache-in-memory": "4.14.0", - "@algolia/client-account": "4.14.0", - "@algolia/client-analytics": "4.14.0", - "@algolia/client-common": "4.14.0", - "@algolia/client-personalization": "4.14.0", - "@algolia/client-search": "4.14.0", - "@algolia/logger-common": "4.14.0", - "@algolia/logger-console": "4.14.0", - "@algolia/requester-browser-xhr": "4.14.0", - "@algolia/requester-common": "4.14.0", - "@algolia/requester-node-http": "4.14.0", - "@algolia/transporter": "4.14.0" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-4.23.3.tgz", + "integrity": "sha512-Le/3YgNvjW9zxIQMRhUHuhiUjAlKY/zsdZpfq4dlLqg6mEm0nL6yk+7f2hDOtLpxsgE4jSzDmvHL7nXdBp5feg==", + "requires": { + "@algolia/cache-browser-local-storage": "4.23.3", + "@algolia/cache-common": "4.23.3", + "@algolia/cache-in-memory": "4.23.3", + "@algolia/client-account": "4.23.3", + "@algolia/client-analytics": "4.23.3", + "@algolia/client-common": "4.23.3", + "@algolia/client-personalization": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/logger-console": "4.23.3", + "@algolia/recommend": "4.23.3", + "@algolia/requester-browser-xhr": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/requester-node-http": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "algoliasearch-helper": { - "version": "3.10.0", - "resolved": "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.10.0.tgz", - "integrity": "sha512-4E4od8qWWDMVvQ3jaRX6Oks/k35ywD011wAA4LbYMMjOtaZV6VWaTjRr4iN2bdaXP2o1BP7SLFMBf3wvnHmd8Q==", + "version": "3.17.0", + "resolved": "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.17.0.tgz", + "integrity": "sha512-R5422OiQjvjlK3VdpNQ/Qk7KsTIGeM5ACm8civGifOVWdRRV/3SgXuKmeNxe94Dz6fwj/IgpVmXbHutU4mHubg==", "requires": { "@algolia/events": "^4.0.1" } @@ -16487,13 +17116,13 @@ "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==" }, "autoprefixer": { - "version": "10.4.7", - "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.7.tgz", - "integrity": "sha512-ypHju4Y2Oav95SipEcCcI5J7CGPuvz8oat7sUtYj3ClK44bldfvtvcxK6IEK++7rqB7YchDGzweZIBG+SD0ZAA==", + "version": "10.4.19", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.19.tgz", + "integrity": "sha512-BaENR2+zBZ8xXhM4pUaKUxlVdxZ0EZhjvbopwnXmxRUfqDmwSpC2lAi/QXvx7NRdPCo1WKEcEF6mV64si1z4Ew==", "requires": { - "browserslist": "^4.20.3", - "caniuse-lite": "^1.0.30001335", - "fraction.js": "^4.2.0", + "browserslist": "^4.23.0", + "caniuse-lite": "^1.0.30001599", + "fraction.js": "^4.3.7", "normalize-range": "^0.1.2", "picocolors": "^1.0.0", "postcss-value-parser": "^4.2.0" @@ -16508,14 +17137,26 @@ } }, "babel-loader": { - "version": "8.2.5", - "resolved": "https://registry.npmjs.org/babel-loader/-/babel-loader-8.2.5.tgz", - "integrity": "sha512-OSiFfH89LrEMiWd4pLNqGz4CwJDtbs2ZVc+iGu2HrkRfPxId9F2anQj38IxWpmRfsUY0aBZYi1EFcd3mhtRMLQ==", + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/babel-loader/-/babel-loader-8.3.0.tgz", + "integrity": "sha512-H8SvsMF+m9t15HNLMipppzkC+Y2Yq+v3SonZyU70RBL/h1gxPkH08Ot8pEE9Z4Kd+czyWJClmFS8qzIP9OZ04Q==", "requires": { "find-cache-dir": "^3.3.1", "loader-utils": "^2.0.0", "make-dir": "^3.1.0", "schema-utils": "^2.6.5" + }, + "dependencies": { + "schema-utils": { + "version": "2.7.1", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.1.tgz", + "integrity": "sha512-SHiNtMOUGWBQJwzISiVYKu82GiV4QYGePp3odlY1tuKO7gPtphAT5R/py0fA6xtbgLL/RvtJZnU9b8s0F1q0Xg==", + "requires": { + "@types/json-schema": "^7.0.5", + "ajv": "^6.12.4", + "ajv-keywords": "^3.5.2" + } + } } }, "babel-plugin-apply-mdx-type-prop": { @@ -16558,37 +17199,37 @@ } }, "babel-plugin-polyfill-corejs2": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.3.1.tgz", - "integrity": "sha512-v7/T6EQcNfVLfcN2X8Lulb7DjprieyLWJK/zOWH5DUYcAgex9sP3h25Q+DLsX9TloXe3y1O8l2q2Jv9q8UVB9w==", + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.6.tgz", + "integrity": "sha512-jhHiWVZIlnPbEUKSSNb9YoWcQGdlTLq7z1GHL4AjFxaoOUMuuEVJ+Y4pAaQUGOGk93YsVCKPbqbfw3m0SM6H8Q==", "requires": { - "@babel/compat-data": "^7.13.11", - "@babel/helper-define-polyfill-provider": "^0.3.1", - "semver": "^6.1.1" + "@babel/compat-data": "^7.22.6", + "@babel/helper-define-polyfill-provider": "^0.4.3", + "semver": "^6.3.1" }, "dependencies": { "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==" } } }, "babel-plugin-polyfill-corejs3": { - "version": "0.5.2", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.5.2.tgz", - "integrity": "sha512-G3uJih0XWiID451fpeFaYGVuxHEjzKTHtc9uGFEjR6hHrvNzeS/PX+LLLcetJcytsB5m4j+K3o/EpXJNb/5IEQ==", + "version": "0.8.6", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.8.6.tgz", + "integrity": "sha512-leDIc4l4tUgU7str5BWLS2h8q2N4Nf6lGZP6UrNDxdtfF2g69eJ5L0H7S8A5Ln/arfFAfHor5InAdZuIOwZdgQ==", "requires": { - "@babel/helper-define-polyfill-provider": "^0.3.1", - "core-js-compat": "^3.21.0" + "@babel/helper-define-polyfill-provider": "^0.4.3", + "core-js-compat": "^3.33.1" } }, "babel-plugin-polyfill-regenerator": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.3.1.tgz", - "integrity": "sha512-Y2B06tvgHYt1x0yz17jGkGeeMr5FeKUu+ASJ+N6nB5lQ8Dapfg42i0OVrf8PNGJ3zKL4A23snMi1IRwrqqND7A==", + "version": "0.5.3", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.5.3.tgz", + "integrity": "sha512-8sHeDOmXC8csczMrYEOf0UTNa4yE2SxV5JGeT/LP1n0OYVDUUFPxG9vdk2AlDlIit4t+Kf0xCtpgXPBwnn/9pw==", "requires": { - "@babel/helper-define-polyfill-provider": "^0.3.1" + "@babel/helper-define-polyfill-provider": "^0.4.3" } }, "bail": { @@ -16622,20 +17263,20 @@ "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==" }, "body-parser": { - "version": "1.20.0", - "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.0.tgz", - "integrity": "sha512-DfJ+q6EPcGKZD1QWUjSpqp+Q7bDQTsQIF4zfUAtZ6qk+H/3/QRhg9CEp39ss+/T2vw0+HaidC0ecJj/DRLIaKg==", + "version": "1.20.3", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz", + "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==", "requires": { "bytes": "3.1.2", - "content-type": "~1.0.4", + "content-type": "~1.0.5", "debug": "2.6.9", "depd": "2.0.0", "destroy": "1.2.0", "http-errors": "2.0.0", "iconv-lite": "0.4.24", "on-finished": "2.4.1", - "qs": "6.10.3", - "raw-body": "2.5.1", + "qs": "6.13.0", + "raw-body": "2.5.2", "type-is": "~1.6.18", "unpipe": "1.0.0" }, @@ -16661,9 +17302,9 @@ } }, "bonjour-service": { - "version": "1.0.13", - "resolved": "https://registry.npmjs.org/bonjour-service/-/bonjour-service-1.0.13.tgz", - "integrity": "sha512-LWKRU/7EqDUC9CTAQtuZl5HzBALoCYwtLhffW3et7vZMwv3bWLpJf8bRYlMD5OCcDpTfnPgNCV4yo9ZIaJGMiA==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/bonjour-service/-/bonjour-service-1.1.1.tgz", + "integrity": "sha512-Z/5lQRMOG9k7W+FkeGTNjh7htqn/2LMnfOvBZ8pynNZCM9MwkQkI3zeI4oz09uWdcgmgHugVvBqxGg4VQJ5PCg==", "requires": { "array-flatten": "^2.1.2", "dns-equal": "^1.0.0", @@ -16701,22 +17342,22 @@ } }, "braces": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", - "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", "requires": { - "fill-range": "^7.0.1" + "fill-range": "^7.1.1" } }, "browserslist": { - "version": "4.21.2", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.2.tgz", - "integrity": "sha512-MonuOgAtUB46uP5CezYbRaYKBNt2LxP0yX+Pmj4LkcDFGkn9Cbpi83d9sCjwQDErXsIJSzY5oKGDbgOlF/LPAA==", + "version": "4.23.0", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.0.tgz", + "integrity": "sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==", "requires": { - "caniuse-lite": "^1.0.30001366", - "electron-to-chromium": "^1.4.188", - "node-releases": "^2.0.6", - "update-browserslist-db": "^1.0.4" + "caniuse-lite": "^1.0.30001587", + "electron-to-chromium": "^1.4.668", + "node-releases": "^2.0.14", + "update-browserslist-db": "^1.0.13" } }, "buble": { @@ -16799,11 +17440,6 @@ "unicode-match-property-value-ecmascript": "^2.0.0" } }, - "regjsgen": { - "version": "0.5.2", - "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.2.tgz", - "integrity": "sha512-OFFT3MfrH90xIW8OOSyUrk6QHD5E9JOTeGodiJeBS3J6IwlgzJMNE/1bZklWz5oTg+9dCMyEetclvCVXOPoN3A==" - }, "regjsparser": { "version": "0.7.0", "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.7.0.tgz", @@ -16867,12 +17503,15 @@ } }, "call-bind": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", - "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz", + "integrity": "sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==", "requires": { - "function-bind": "^1.1.1", - "get-intrinsic": "^1.0.2" + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "set-function-length": "^1.2.1" } }, "callsites": { @@ -16911,9 +17550,9 @@ } }, "caniuse-lite": { - "version": "1.0.30001367", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001367.tgz", - "integrity": "sha512-XDgbeOHfifWV3GEES2B8rtsrADx4Jf+juKX2SICJcaUhjYBO3bR96kvEIHa15VU6ohtOhBZuPGGYGbXMRn0NCw==" + "version": "1.0.30001611", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001611.tgz", + "integrity": "sha512-19NuN1/3PjA3QI8Eki55N8my4LzfkMCRLgCVfrl/slbSAchQfV0+GwjPrK3rq37As4UCLlM/DHajbKkAqbv92Q==" }, "ccount": { "version": "1.1.0", @@ -16962,6 +17601,47 @@ "htmlparser2": "^8.0.1", "parse5": "^7.0.0", "parse5-htmlparser2-tree-adapter": "^7.0.0" + }, + "dependencies": { + "dom-serializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", + "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "requires": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "entities": "^4.2.0" + } + }, + "domhandler": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "requires": { + "domelementtype": "^2.3.0" + } + }, + "domutils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.1.0.tgz", + "integrity": "sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==", + "requires": { + "dom-serializer": "^2.0.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3" + } + }, + "htmlparser2": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz", + "integrity": "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==", + "requires": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1", + "entities": "^4.4.0" + } + } } }, "cheerio-select": { @@ -16975,6 +17655,48 @@ "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.0.1" + }, + "dependencies": { + "css-select": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz", + "integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==", + "requires": { + "boolbase": "^1.0.0", + "css-what": "^6.1.0", + "domhandler": "^5.0.2", + "domutils": "^3.0.1", + "nth-check": "^2.0.1" + } + }, + "dom-serializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", + "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "requires": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "entities": "^4.2.0" + } + }, + "domhandler": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "requires": { + "domelementtype": "^2.3.0" + } + }, + "domutils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.1.0.tgz", + "integrity": "sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==", + "requires": { + "dom-serializer": "^2.0.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3" + } + } } }, "chokidar": { @@ -16998,14 +17720,14 @@ "integrity": "sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==" }, "ci-info": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz", - "integrity": "sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==" + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz", + "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==" }, "clean-css": { - "version": "5.3.1", - "resolved": "https://registry.npmjs.org/clean-css/-/clean-css-5.3.1.tgz", - "integrity": "sha512-lCr8OHhiWCTw4v8POJovCoh4T7I9U11yVsPjMWWnnMmp9ZowCxyad1Pathle/9HjaDp+fdQKjO9fQydE6RHTZg==", + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/clean-css/-/clean-css-5.3.2.tgz", + "integrity": "sha512-JVJbM+f3d3Q704rF4bqQ5UUyTtuJ0JRKNbTKVEeujCCBoMdkEi+V+e8oktO9qGQNSvHrFTM6JZRXrUvGR1czww==", "requires": { "source-map": "~0.6.0" } @@ -17021,9 +17743,9 @@ "integrity": "sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==" }, "cli-table3": { - "version": "0.6.2", - "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.2.tgz", - "integrity": "sha512-QyavHCaIC80cMivimWu4aWHilIpiDpfm3hGmqAmXVL1UsnbLuBSMd21hTX6VY4ZSDSM73ESLeF8TOYId3rBTbw==", + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.3.tgz", + "integrity": "sha512-w5Jac5SykAeZJKntOxJCrm63Eg5/4dhMWIcuTbo9rpE+brgaSZo0RuNJZeOyMgsUdhDeojvgyQLmjI+K50ZGyg==", "requires": { "@colors/colors": "1.5.0", "string-width": "^4.2.0" @@ -17093,14 +17815,14 @@ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" }, "colord": { - "version": "2.9.2", - "resolved": "https://registry.npmjs.org/colord/-/colord-2.9.2.tgz", - "integrity": "sha512-Uqbg+J445nc1TKn4FoDPS6ZZqAvEDnwrH42yo8B40JSOgSLxMZ/gt3h4nmCtPLQeXhjJJkqBx7SCY35WnIixaQ==" + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/colord/-/colord-2.9.3.tgz", + "integrity": "sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==" }, "colorette": { - "version": "2.0.19", - "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.19.tgz", - "integrity": "sha512-3tlv/dIP7FWvj3BsbHrGLJ6l/oKh1O3TcgBqMn+yyCagOxc23fyzDS6HypQbgxWbkpDnf52p1LuR4eWDQ/K9WQ==" + "version": "2.0.20", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz", + "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==" }, "combine-promises": { "version": "1.1.0", @@ -17210,22 +17932,19 @@ "integrity": "sha512-kRGRZw3bLlFISDBgwTSA1TMBFN6J6GWDeubmDE3AF+3+yXL8hTWv8r5rkLbqYXY4RjPk/EzHnClI3zQf1cFmHA==" }, "content-type": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz", - "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==" + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==" }, "convert-source-map": { - "version": "1.8.0", - "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.8.0.tgz", - "integrity": "sha512-+OQdjP49zViI/6i7nIJpA8rAl4sV/JdPfU9nZs3VqOwGIgizICvuN2ru6fMd+4llL0tar18UYJXfZ/TWtmhUjA==", - "requires": { - "safe-buffer": "~5.1.1" - } + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==" }, "cookie": { - "version": "0.5.0", - "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz", - "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==" + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz", + "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==" }, "cookie-signature": { "version": "1.0.6", @@ -17233,9 +17952,9 @@ "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==" }, "copy-text-to-clipboard": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/copy-text-to-clipboard/-/copy-text-to-clipboard-3.0.1.tgz", - "integrity": "sha512-rvVsHrpFcL4F2P8ihsoLdFHmd404+CMg71S756oRSeQgqk51U3kicGdnvfkrxva0xXH92SjGS62B0XIJsbh+9Q==" + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/copy-text-to-clipboard/-/copy-text-to-clipboard-3.2.0.tgz", + "integrity": "sha512-RnJFp1XR/LOBDckxTib5Qjr/PMfkatD0MUCQgdpqS8MdKiNUzBjAQBEN6oUy+jW7LI93BBG3DtMB2KOOKpGs2Q==" }, "copy-webpack-plugin": { "version": "11.0.0", @@ -17250,25 +17969,6 @@ "serialize-javascript": "^6.0.0" }, "dependencies": { - "ajv": { - "version": "8.11.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz", - "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==", - "requires": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - } - }, - "ajv-keywords": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", - "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", - "requires": { - "fast-deep-equal": "^3.1.3" - } - }, "glob-parent": { "version": "6.0.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", @@ -17289,22 +17989,6 @@ "slash": "^4.0.0" } }, - "json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" - }, - "schema-utils": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", - "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", - "requires": { - "@types/json-schema": "^7.0.9", - "ajv": "^8.8.0", - "ajv-formats": "^2.1.1", - "ajv-keywords": "^5.0.0" - } - }, "slash": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz", @@ -17313,30 +17997,22 @@ } }, "core-js": { - "version": "3.23.5", - "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.23.5.tgz", - "integrity": "sha512-7Vh11tujtAZy82da4duVreQysIoO2EvVrur7y6IzZkH1IHPSekuDi8Vuw1+YKjkbfWLRD7Nc9ICQ/sIUDutcyg==" + "version": "3.33.2", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.33.2.tgz", + "integrity": "sha512-XeBzWI6QL3nJQiHmdzbAOiMYqjrb7hwU7A39Qhvd/POSa/t9E1AeZyEZx3fNvp/vtM8zXwhoL0FsiS0hD0pruQ==" }, "core-js-compat": { - "version": "3.23.5", - "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.23.5.tgz", - "integrity": "sha512-fHYozIFIxd+91IIbXJgWd/igXIc8Mf9is0fusswjnGIWVG96y2cwyUdlCkGOw6rMLHKAxg7xtCIVaHsyOUnJIg==", + "version": "3.33.2", + "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.33.2.tgz", + "integrity": "sha512-axfo+wxFVxnqf8RvxTzoAlzW4gRoacrHeoFlc9n0x50+7BEyZL/Rt3hicaED1/CEd7I6tPCPVUYcJwCMO5XUYw==", "requires": { - "browserslist": "^4.21.2", - "semver": "7.0.0" - }, - "dependencies": { - "semver": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.0.0.tgz", - "integrity": "sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==" - } + "browserslist": "^4.22.1" } }, "core-js-pure": { - "version": "3.23.5", - "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.23.5.tgz", - "integrity": "sha512-8t78LdpKSuCq4pJYCYk8hl7XEkAX+BP16yRIwL3AanTksxuEf7CM83vRyctmiEL8NDZ3jpUcv56fk9/zG3aIuw==" + "version": "3.33.2", + "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.33.2.tgz", + "integrity": "sha512-a8zeCdyVk7uF2elKIGz67AjcXOxjRbwOLz8SbklEso1V+2DoW4OkAMZN9S9GBgvZIaqQi/OemFX4OiSoQEmg1Q==" }, "core-util-is": { "version": "1.0.3", @@ -17344,9 +18020,9 @@ "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==" }, "cosmiconfig": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.0.1.tgz", - "integrity": "sha512-a1YWNUV2HwGimB7dU2s1wUMurNKjpx60HxBB6xUM8Re+2s1g1IIfJvFR0/iCF+XHdE0GMTKTuLR32UQff4TEyQ==", + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.1.0.tgz", + "integrity": "sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==", "requires": { "@types/parse-json": "^4.0.0", "import-fresh": "^3.2.1", @@ -17356,17 +18032,17 @@ } }, "cross-fetch": { - "version": "3.1.5", - "resolved": "https://registry.npmjs.org/cross-fetch/-/cross-fetch-3.1.5.tgz", - "integrity": "sha512-lvb1SBsI0Z7GDwmuid+mU3kWVBwTVUbe7S0H52yaaAdQOXq2YktTCZdlAcNKFzE6QtRz0snpw9bNiPeOIkkQvw==", + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/cross-fetch/-/cross-fetch-3.1.8.tgz", + "integrity": "sha512-cvA+JwZoU0Xq+h6WkMvAUqPEYy92Obet6UdKLfW60qn99ftItKjB5T+BkyWOFWe2pUyfQ+IJHmpOTznqk1M6Kg==", "requires": { - "node-fetch": "2.6.7" + "node-fetch": "^2.6.12" } }, "cross-spawn": { - "version": "7.0.3", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", - "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", "requires": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", @@ -17379,85 +18055,69 @@ "integrity": "sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==" }, "css-declaration-sorter": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-6.3.0.tgz", - "integrity": "sha512-OGT677UGHJTAVMRhPO+HJ4oKln3wkBTwtDFH0ojbqm+MJm6xuDMHp2nkhh/ThaBqq20IbraBQSWKfSLNHQO9Og==", + "version": "6.4.1", + "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-6.4.1.tgz", + "integrity": "sha512-rtdthzxKuyq6IzqX6jEcIzQF/YqccluefyCYheovBOLhFT/drQA9zj/UbRAa9J7C0o6EG6u3E6g+vKkay7/k3g==", "requires": {} }, "css-loader": { - "version": "6.7.1", - "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-6.7.1.tgz", - "integrity": "sha512-yB5CNFa14MbPJcomwNh3wLThtkZgcNyI2bNMRt8iE5Z8Vwl7f8vQXFAzn2HDOJvtDq2NTZBUGMSUNNyrv3/+cw==", + "version": "6.8.1", + "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-6.8.1.tgz", + "integrity": "sha512-xDAXtEVGlD0gJ07iclwWVkLoZOpEvAWaSyf6W18S2pOC//K8+qUDIx8IIT3D+HjnmkJPQeesOPv5aiUaJsCM2g==", "requires": { "icss-utils": "^5.1.0", - "postcss": "^8.4.7", + "postcss": "^8.4.21", "postcss-modules-extract-imports": "^3.0.0", - "postcss-modules-local-by-default": "^4.0.0", + "postcss-modules-local-by-default": "^4.0.3", "postcss-modules-scope": "^3.0.0", "postcss-modules-values": "^4.0.0", "postcss-value-parser": "^4.2.0", - "semver": "^7.3.5" + "semver": "^7.3.8" } }, "css-minimizer-webpack-plugin": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-4.0.0.tgz", - "integrity": "sha512-7ZXXRzRHvofv3Uac5Y+RkWRNo0ZMlcg8e9/OtrqUYmwDWJo+qs67GvdeFrXLsFb7czKNwjQhPkM0avlIYl+1nA==", + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-4.2.2.tgz", + "integrity": "sha512-s3Of/4jKfw1Hj9CxEO1E5oXhQAxlayuHO2y/ML+C6I9sQ7FdzfEV6QgMLN3vI+qFsjJGIAFLKtQK7t8BOXAIyA==", "requires": { "cssnano": "^5.1.8", - "jest-worker": "^27.5.1", - "postcss": "^8.4.13", + "jest-worker": "^29.1.2", + "postcss": "^8.4.17", "schema-utils": "^4.0.0", "serialize-javascript": "^6.0.0", "source-map": "^0.6.1" }, "dependencies": { - "ajv": { - "version": "8.11.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz", - "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==", - "requires": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - } - }, - "ajv-keywords": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", - "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "jest-worker": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-29.7.0.tgz", + "integrity": "sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==", "requires": { - "fast-deep-equal": "^3.1.3" + "@types/node": "*", + "jest-util": "^29.7.0", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" } }, - "json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" - }, - "schema-utils": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", - "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", + "supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", "requires": { - "@types/json-schema": "^7.0.9", - "ajv": "^8.8.0", - "ajv-formats": "^2.1.1", - "ajv-keywords": "^5.0.0" + "has-flag": "^4.0.0" } } } }, "css-select": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz", - "integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==", + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz", + "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==", "requires": { "boolbase": "^1.0.0", - "css-what": "^6.1.0", - "domhandler": "^5.0.2", - "domutils": "^3.0.1", + "css-what": "^6.0.1", + "domhandler": "^4.3.1", + "domutils": "^2.8.0", "nth-check": "^2.0.1" } }, @@ -17481,22 +18141,22 @@ "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==" }, "cssnano": { - "version": "5.1.12", - "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-5.1.12.tgz", - "integrity": "sha512-TgvArbEZu0lk/dvg2ja+B7kYoD7BBCmn3+k58xD0qjrGHsFzXY/wKTo9M5egcUCabPol05e/PVoIu79s2JN4WQ==", + "version": "5.1.15", + "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-5.1.15.tgz", + "integrity": "sha512-j+BKgDcLDQA+eDifLx0EO4XSA56b7uut3BQFH+wbSaSTuGLuiyTa/wbRYthUXX8LC9mLg+WWKe8h+qJuwTAbHw==", "requires": { - "cssnano-preset-default": "^5.2.12", + "cssnano-preset-default": "^5.2.14", "lilconfig": "^2.0.3", "yaml": "^1.10.2" } }, "cssnano-preset-advanced": { - "version": "5.3.8", - "resolved": "https://registry.npmjs.org/cssnano-preset-advanced/-/cssnano-preset-advanced-5.3.8.tgz", - "integrity": "sha512-xUlLLnEB1LjpEik+zgRNlk8Y/koBPPtONZjp7JKbXigeAmCrFvq9H0pXW5jJV45bQWAlmJ0sKy+IMr0XxLYQZg==", + "version": "5.3.10", + "resolved": "https://registry.npmjs.org/cssnano-preset-advanced/-/cssnano-preset-advanced-5.3.10.tgz", + "integrity": "sha512-fnYJyCS9jgMU+cmHO1rPSPf9axbQyD7iUhLO5Df6O4G+fKIOMps+ZbU0PdGFejFBBZ3Pftf18fn1eG7MAPUSWQ==", "requires": { - "autoprefixer": "^10.3.7", - "cssnano-preset-default": "^5.2.12", + "autoprefixer": "^10.4.12", + "cssnano-preset-default": "^5.2.14", "postcss-discard-unused": "^5.1.0", "postcss-merge-idents": "^5.1.1", "postcss-reduce-idents": "^5.2.0", @@ -17504,24 +18164,24 @@ } }, "cssnano-preset-default": { - "version": "5.2.12", - "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-5.2.12.tgz", - "integrity": "sha512-OyCBTZi+PXgylz9HAA5kHyoYhfGcYdwFmyaJzWnzxuGRtnMw/kR6ilW9XzlzlRAtB6PLT/r+prYgkef7hngFew==", + "version": "5.2.14", + "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-5.2.14.tgz", + "integrity": "sha512-t0SFesj/ZV2OTylqQVOrFgEh5uanxbO6ZAdeCrNsUQ6fVuXwYTxJPNAGvGTxHbD68ldIJNec7PyYZDBrfDQ+6A==", "requires": { - "css-declaration-sorter": "^6.3.0", + "css-declaration-sorter": "^6.3.1", "cssnano-utils": "^3.1.0", "postcss-calc": "^8.2.3", - "postcss-colormin": "^5.3.0", - "postcss-convert-values": "^5.1.2", + "postcss-colormin": "^5.3.1", + "postcss-convert-values": "^5.1.3", "postcss-discard-comments": "^5.1.2", "postcss-discard-duplicates": "^5.1.0", "postcss-discard-empty": "^5.1.1", "postcss-discard-overridden": "^5.1.0", - "postcss-merge-longhand": "^5.1.6", - "postcss-merge-rules": "^5.1.2", + "postcss-merge-longhand": "^5.1.7", + "postcss-merge-rules": "^5.1.4", "postcss-minify-font-values": "^5.1.0", "postcss-minify-gradients": "^5.1.1", - "postcss-minify-params": "^5.1.3", + "postcss-minify-params": "^5.1.4", "postcss-minify-selectors": "^5.2.1", "postcss-normalize-charset": "^5.1.0", "postcss-normalize-display-values": "^5.1.0", @@ -17529,11 +18189,11 @@ "postcss-normalize-repeat-style": "^5.1.1", "postcss-normalize-string": "^5.1.0", "postcss-normalize-timing-functions": "^5.1.0", - "postcss-normalize-unicode": "^5.1.0", + "postcss-normalize-unicode": "^5.1.1", "postcss-normalize-url": "^5.1.0", "postcss-normalize-whitespace": "^5.1.1", "postcss-ordered-values": "^5.1.3", - "postcss-reduce-initial": "^5.1.0", + "postcss-reduce-initial": "^5.1.2", "postcss-reduce-transforms": "^5.1.0", "postcss-svgo": "^5.1.0", "postcss-unique-selectors": "^5.1.1" @@ -17558,6 +18218,11 @@ "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.0.tgz", "integrity": "sha512-uX1KG+x9h5hIJsaKR9xHUeUraxf8IODOwq9JLNPq6BwB04a/xgpq3rcx47l5BZu5zBPlgD342tdke3Hom/nJRA==" }, + "debounce": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/debounce/-/debounce-1.2.1.tgz", + "integrity": "sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==" + }, "debug": { "version": "4.3.4", "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", @@ -17597,6 +18262,16 @@ "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-1.1.3.tgz", "integrity": "sha512-0ISdNousHvZT2EiFlZeZAHBUvSxmKswVCEf8hW7KWgG4a8MVEu/3Vb6uWYozkjylyCxe0JBIiRB1jV45S70WVQ==" }, + "define-data-property": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", + "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", + "requires": { + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.0.1" + } + }, "define-lazy-prop": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz", @@ -17650,27 +18325,12 @@ "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==" }, "detect-port": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/detect-port/-/detect-port-1.3.0.tgz", - "integrity": "sha512-E+B1gzkl2gqxt1IhUzwjrxBKRqx1UzC3WLONHinn8S3T6lwV/agVCyitiFOsGJ/eYuEUBvD71MZHy3Pv1G9doQ==", + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/detect-port/-/detect-port-1.5.1.tgz", + "integrity": "sha512-aBzdj76lueB6uUst5iAs7+0H/oOjqI5D16XUWxlWMIMROhcM0rfsNVk93zTngq1dDNpoXRr++Sus7ETAExppAQ==", "requires": { "address": "^1.0.1", - "debug": "^2.6.0" - }, - "dependencies": { - "debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", - "requires": { - "ms": "2.0.0" - } - }, - "ms": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" - } + "debug": "4" } }, "detect-port-alt": { @@ -17711,17 +18371,17 @@ "integrity": "sha512-z+paD6YUQsk+AbGCEM4PrOXSss5gd66QfcVBFTKR/HpFL9jCqikS94HYwKww6fQyO7IxrIIyUu+g0Ka9tUS2Cg==" }, "dns-packet": { - "version": "5.4.0", - "resolved": "https://registry.npmjs.org/dns-packet/-/dns-packet-5.4.0.tgz", - "integrity": "sha512-EgqGeaBB8hLiHLZtp/IbaDQTL8pZ0+IvwzSHA6d7VyMDM+B9hgddEMa9xjK5oYnw0ci0JQ6g2XCD7/f6cafU6g==", + "version": "5.6.1", + "resolved": "https://registry.npmjs.org/dns-packet/-/dns-packet-5.6.1.tgz", + "integrity": "sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==", "requires": { "@leichtgewicht/ip-codec": "^2.0.1" } }, "docusaurus-plugin-sass": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/docusaurus-plugin-sass/-/docusaurus-plugin-sass-0.2.2.tgz", - "integrity": "sha512-ZZBpj3PrhGpYE2kAnkZB9NRwy/CDi4rGun1oec6PYR8YvGzqxYGtXvLgHi6FFbu8/N483klk8udqyYMh6Ted+A==", + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/docusaurus-plugin-sass/-/docusaurus-plugin-sass-0.2.5.tgz", + "integrity": "sha512-Z+D0fLFUKcFpM+bqSUmqKIU+vO+YF1xoEQh5hoFreg2eMf722+siwXDD+sqtwU8E4MvVpuvsQfaHwODNlxJAEg==", "requires": { "sass-loader": "^10.1.1" } @@ -17744,19 +18404,19 @@ } }, "dom-serializer": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", - "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz", + "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==", "requires": { - "domelementtype": "^2.3.0", - "domhandler": "^5.0.2", - "entities": "^4.2.0" + "domelementtype": "^2.0.1", + "domhandler": "^4.2.0", + "entities": "^2.0.0" }, "dependencies": { "entities": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/entities/-/entities-4.3.1.tgz", - "integrity": "sha512-o4q/dYJlmyjP2zfnaWDUC6A3BQFmVTX+tZPezK7k0GLSU9QYCauscf5Y+qcEPzKL+EixVouYDgLQK5H9GrLpkg==" + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", + "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==" } } }, @@ -17766,21 +18426,21 @@ "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==" }, "domhandler": { - "version": "5.0.3", - "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", - "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz", + "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==", "requires": { - "domelementtype": "^2.3.0" + "domelementtype": "^2.2.0" } }, "domutils": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.0.1.tgz", - "integrity": "sha512-z08c1l761iKhDFtfXO04C7kTdPBLi41zwOZl00WS8b5eiaebNpY00HKbztwBq+e3vyqWNwWF3mP9YLUeqIrF+Q==", + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz", + "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==", "requires": { - "dom-serializer": "^2.0.0", - "domelementtype": "^2.3.0", - "domhandler": "^5.0.1" + "dom-serializer": "^1.0.1", + "domelementtype": "^2.2.0", + "domhandler": "^4.2.0" } }, "dot-case": { @@ -17828,9 +18488,9 @@ "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==" }, "electron-to-chromium": { - "version": "1.4.192", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.192.tgz", - "integrity": "sha512-8nCXyIQY9An88NXAp+PuPy5h3/w5ZY7Iu2lag65Q0XREprcat5F8gKhoHsBUnQcFuCRnmevpR8yEBYRU3d2HDw==" + "version": "1.4.741", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.741.tgz", + "integrity": "sha512-AyTBZqDoS7/mvQK22gOQpjxbeV8iPeUBTvYlEh/1S9dKAHgQdxuF49g9rLbj0cRKtqH8PzLJzqT3nAdl+qoZTA==" }, "emoji-regex": { "version": "9.2.2", @@ -17848,9 +18508,9 @@ "integrity": "sha512-SNujglcLTTg+lDAcApPNgEdudaqQFiAbJCqzjNxJkvN9vAwCGi0uu8IUVvx+f16h+V44KCY6Y2yboroc9pilHg==" }, "encodeurl": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", - "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==" + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==" }, "end-of-stream": { "version": "1.4.4", @@ -17861,18 +18521,18 @@ } }, "enhanced-resolve": { - "version": "5.10.0", - "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.10.0.tgz", - "integrity": "sha512-T0yTFjdpldGY8PmuXXR0PyQ1ufZpEGiHVrp7zHKB7jdR4qlmZHhONVM5AQOAWXuF/w3dnHbEQVrNptJgt7F+cQ==", + "version": "5.17.1", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.17.1.tgz", + "integrity": "sha512-LMHl3dXhTcfv8gM4kEzIUeTQ+7fpdA0l2tUf34BddXPkz2A5xJ5L/Pchd5BL6rdccM9QGvu0sWZzK1Z1t4wwyg==", "requires": { "graceful-fs": "^4.2.4", "tapable": "^2.2.0" } }, "entities": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/entities/-/entities-3.0.1.tgz", - "integrity": "sha512-WiyBqoomrwMdFG1e0kqvASYfnlb0lp8M5o5Fw2OFq1hNZxxcNk8Ik0Xm7LxzBhuidnZB/UtBqVCgUz3kBOP51Q==" + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", + "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==" }, "error-ex": { "version": "1.3.2", @@ -17882,10 +18542,23 @@ "is-arrayish": "^0.2.1" } }, + "es-define-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz", + "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==", + "requires": { + "get-intrinsic": "^1.2.4" + } + }, + "es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==" + }, "es-module-lexer": { - "version": "0.9.3", - "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-0.9.3.tgz", - "integrity": "sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ==" + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.4.1.tgz", + "integrity": "sha512-cXLGjP0c4T3flZJKQSuziYoq7MlT+rnvfZjfp7h+I7K9BNX54kP9nyWvdbwjQ4u1iWbOL4u96fgeZLToQlZC7w==" }, "escalade": { "version": "3.1.1", @@ -17947,9 +18620,9 @@ "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==" }, "eta": { - "version": "1.12.3", - "resolved": "https://registry.npmjs.org/eta/-/eta-1.12.3.tgz", - "integrity": "sha512-qHixwbDLtekO/d51Yr4glcaUJCIjGVJyTzuqV4GPlgZo1YpgOKG+avQynErZIYrfM6JIJdtiG2Kox8tbb+DoGg==" + "version": "1.14.2", + "resolved": "https://registry.npmjs.org/eta/-/eta-1.14.2.tgz", + "integrity": "sha512-wZmJAV7EFUG5W8XNXSazIdichnWEhGB1OWg4tnXWPj0CPNUcFdgorGNO6N9p6WBUgoUe4P0OziJYn1+6zxP2aQ==" }, "etag": { "version": "1.8.1", @@ -17989,46 +18662,39 @@ "onetime": "^5.1.2", "signal-exit": "^3.0.3", "strip-final-newline": "^2.0.0" - }, - "dependencies": { - "get-stream": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", - "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==" - } } }, "express": { - "version": "4.18.1", - "resolved": "https://registry.npmjs.org/express/-/express-4.18.1.tgz", - "integrity": "sha512-zZBcOX9TfehHQhtupq57OF8lFZ3UZi08Y97dwFCkD8p9d/d2Y3M+ykKcwaMDEL+4qyUolgBDX6AblpR3fL212Q==", + "version": "4.21.1", + "resolved": "https://registry.npmjs.org/express/-/express-4.21.1.tgz", + "integrity": "sha512-YSFlK1Ee0/GC8QaO91tHcDxJiE/X4FbpAyQWkxAvG6AXCuR65YzK8ua6D9hvi/TzUfZMpc+BwuM1IPw8fmQBiQ==", "requires": { "accepts": "~1.3.8", "array-flatten": "1.1.1", - "body-parser": "1.20.0", + "body-parser": "1.20.3", "content-disposition": "0.5.4", "content-type": "~1.0.4", - "cookie": "0.5.0", + "cookie": "0.7.1", "cookie-signature": "1.0.6", "debug": "2.6.9", "depd": "2.0.0", - "encodeurl": "~1.0.2", + "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "etag": "~1.8.1", - "finalhandler": "1.2.0", + "finalhandler": "1.3.1", "fresh": "0.5.2", "http-errors": "2.0.0", - "merge-descriptors": "1.0.1", + "merge-descriptors": "1.0.3", "methods": "~1.1.2", "on-finished": "2.4.1", "parseurl": "~1.3.3", - "path-to-regexp": "0.1.7", + "path-to-regexp": "0.1.10", "proxy-addr": "~2.0.7", - "qs": "6.10.3", + "qs": "6.13.0", "range-parser": "~1.2.1", "safe-buffer": "5.2.1", - "send": "0.18.0", - "serve-static": "1.15.0", + "send": "0.19.0", + "serve-static": "1.16.2", "setprototypeof": "1.2.0", "statuses": "2.0.1", "type-is": "~1.6.18", @@ -18063,9 +18729,9 @@ "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" }, "path-to-regexp": { - "version": "0.1.7", - "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz", - "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==" + "version": "0.1.10", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.10.tgz", + "integrity": "sha512-7lf7qcQidTku0Gu3YDPc8DJ1q7OOucfa/BSsIwjuh56VU7katFvuM8hULfkwB3Fns/rsVF7PwPKVw1sl5KQS9w==" }, "range-parser": { "version": "1.2.1", @@ -18147,9 +18813,9 @@ } }, "fbjs": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/fbjs/-/fbjs-3.0.4.tgz", - "integrity": "sha512-ucV0tDODnGV3JCnnkmoszb5lf4bNpzjv80K41wd4k798Etq+UYD0y0TIfalLjZoKgjive6/adkRnszwapiDgBQ==", + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/fbjs/-/fbjs-3.0.5.tgz", + "integrity": "sha512-ztsSx77JBtkuMrEypfhgc3cI0+0h+svqeie7xHbh1k/IKdcydnvadp/mUaGgjAOXQmQSxsqgaRhS3q9fy+1kxg==", "requires": { "cross-fetch": "^3.1.5", "fbjs-css-vars": "^1.0.0", @@ -18157,7 +18823,7 @@ "object-assign": "^4.1.0", "promise": "^7.1.1", "setimmediate": "^1.0.5", - "ua-parser-js": "^0.7.30" + "ua-parser-js": "^1.0.35" } }, "fbjs-css-vars": { @@ -18200,20 +18866,20 @@ "integrity": "sha512-pjmC+bkIF8XI7fWaH8KxHcZL3DPybs1roSKP4rKDvy20tAWwIObE4+JIseG2byfGKhud5ZnM4YSGKBz7Sh0ndQ==" }, "fill-range": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", - "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", "requires": { "to-regex-range": "^5.0.1" } }, "finalhandler": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz", - "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==", + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz", + "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==", "requires": { "debug": "2.6.9", - "encodeurl": "~1.0.2", + "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "on-finished": "2.4.1", "parseurl": "~1.3.3", @@ -18255,19 +18921,24 @@ "path-exists": "^4.0.0" } }, + "flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==" + }, "flux": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/flux/-/flux-4.0.3.tgz", - "integrity": "sha512-yKAbrp7JhZhj6uiT1FTuVMlIAT1J4jqEyBpFApi1kxpGZCvacMVc/t1pMQyotqHhAgvoE3bNvAykhCo2CLjnYw==", + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/flux/-/flux-4.0.4.tgz", + "integrity": "sha512-NCj3XlayA2UsapRpM7va6wU1+9rE5FIL7qoMcmxWHRzbp0yujihMBm9BBHZ1MDIk5h5o2Bl6eGiCe8rYELAmYw==", "requires": { "fbemitter": "^3.0.0", "fbjs": "^3.0.1" } }, "follow-redirects": { - "version": "1.15.1", - "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.1.tgz", - "integrity": "sha512-yLAMQs+k0b2m7cVxpS1VKJVvoz7SS9Td1zss3XRwXj+ZDH00RJgnuLx7E44wx02kQLrdM3aOOy+FpzS7+8OizA==" + "version": "1.15.6", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.6.tgz", + "integrity": "sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==" }, "fork-ts-checker-webpack-plugin": { "version": "6.5.2", @@ -18335,9 +19006,9 @@ "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==" }, "fraction.js": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.2.0.tgz", - "integrity": "sha512-MhLuK+2gUcnZe8ZHlaaINnQLl0xRIGRfcGk2yl8xoQAfHrSsL3rYu6FCmBdkdbhc9EPlwyGHewaRsvwRMJtAlA==" + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz", + "integrity": "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==" }, "fresh": { "version": "0.5.2", @@ -18371,9 +19042,9 @@ "optional": true }, "function-bind": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", - "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==" + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==" }, "gensync": { "version": "1.0.0-beta.2", @@ -18381,13 +19052,15 @@ "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==" }, "get-intrinsic": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.2.tgz", - "integrity": "sha512-Jfm3OyCxHh9DJyc28qGk+JmfkpO41A4XkneDSujN9MDXrm4oDKdHvndhZ2dN94+ERNfkYJWDclW6k2L/ZGHjXA==", + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz", + "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==", "requires": { - "function-bind": "^1.1.1", - "has": "^1.0.3", - "has-symbols": "^1.0.3" + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "hasown": "^2.0.0" } }, "get-own-enumerable-property-symbols": { @@ -18396,17 +19069,14 @@ "integrity": "sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==" }, "get-stream": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz", - "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==", - "requires": { - "pump": "^3.0.0" - } + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==" }, "github-slugger": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/github-slugger/-/github-slugger-1.4.0.tgz", - "integrity": "sha512-w0dzqw/nt51xMVmlaV1+JRzN+oCa1KfcgGEWhxUG16wbdA+Xnt/yoFO8Z8x/V82ZcZ0wy6ln9QDup5avbhiDhQ==" + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/github-slugger/-/github-slugger-1.5.0.tgz", + "integrity": "sha512-wIh+gKBI9Nshz2o46B0B3f5k/W+WI9ZAv6y5Dn5WJ5SK1t0TnDimB4WE5rmTD05ZAIn8HALCZVmCsvj0w0v0lw==" }, "glob": { "version": "7.2.3", @@ -18435,9 +19105,9 @@ "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==" }, "global-dirs": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-3.0.0.tgz", - "integrity": "sha512-v8ho2DS5RiCjftj1nD9NmnfaOzTdud7RRnVd9kFNOjqZbISlx5DQ+OrTkywgd0dIt7oFCvKetZSHoHcP3sDdiA==", + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-3.0.1.tgz", + "integrity": "sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==", "requires": { "ini": "2.0.0" }, @@ -18495,6 +19165,14 @@ "slash": "^3.0.0" } }, + "gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "requires": { + "get-intrinsic": "^1.1.3" + } + }, "got": { "version": "9.6.0", "resolved": "https://registry.npmjs.org/got/-/got-9.6.0.tgz", @@ -18511,12 +19189,22 @@ "p-cancelable": "^1.0.0", "to-readable-stream": "^1.0.0", "url-parse-lax": "^3.0.0" + }, + "dependencies": { + "get-stream": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz", + "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==", + "requires": { + "pump": "^3.0.0" + } + } } }, "graceful-fs": { - "version": "4.2.10", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", - "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==" + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==" }, "gray-matter": { "version": "4.0.3", @@ -18575,13 +19263,18 @@ "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==" }, "has-property-descriptors": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", - "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", + "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", "requires": { - "get-intrinsic": "^1.1.1" + "es-define-property": "^1.0.0" } }, + "has-proto": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz", + "integrity": "sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==" + }, "has-symbols": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", @@ -18592,6 +19285,14 @@ "resolved": "https://registry.npmjs.org/has-yarn/-/has-yarn-2.1.0.tgz", "integrity": "sha512-UqBRqi4ju7T+TqGNdqAO0PaSVGsDGJUBQvk9eUWNGRY1CFGDzYhLWoM7JQEemnlvVcv/YEmc2wNW8BC24EnUsw==" }, + "hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "requires": { + "function-bind": "^1.1.2" + } + }, "hast-to-hyperscript": { "version": "9.0.1", "resolved": "https://registry.npmjs.org/hast-to-hyperscript/-/hast-to-hyperscript-9.0.1.tgz", @@ -18720,9 +19421,9 @@ "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==" }, "readable-stream": { - "version": "2.3.7", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz", - "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==", + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz", + "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==", "requires": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", @@ -18744,9 +19445,14 @@ } }, "html-entities": { - "version": "2.3.3", - "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.3.3.tgz", - "integrity": "sha512-DV5Ln36z34NNTDgnz0EWGBLZENelNAtkiFA4kyNOG2tDI6Mz1uSWiq1wAKdyjnJwyDiDO7Fa2SO1CTxPXL8VxA==" + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.4.0.tgz", + "integrity": "sha512-igBTJcNNNhvZFRtm8uA6xMY6xYleeDwn3PeBCkDz7tHttv4F2hsDI2aPgNERWzvRcNYHNT3ymRaQzllmXj4YsQ==" + }, + "html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==" }, "html-minifier-terser": { "version": "6.1.0", @@ -18770,9 +19476,9 @@ } }, "html-tags": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/html-tags/-/html-tags-3.2.0.tgz", - "integrity": "sha512-vy7ClnArOZwCnqZgvv+ddgHgJiAFXe3Ge9ML5/mBctVJoUoYPCdxVucOywjDARn6CVoh3dRSFdPHy2sX80L0Wg==" + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/html-tags/-/html-tags-3.3.1.tgz", + "integrity": "sha512-ztqyC3kLto0e9WbNp0aeP+M3kTt+nbaIveGmUxAtZa+8iFgKLUOD4YKM5j+f3QD89bra7UeumolZHKuOXnTmeQ==" }, "html-void-elements": { "version": "1.0.5", @@ -18780,9 +19486,9 @@ "integrity": "sha512-uE/TxKuyNIcx44cIWnjr/rfIATDH7ZaOMmstu0CwhFG1Dunhlp4OC6/NMbhiwoq5BpW0ubi303qnEk/PZj614w==" }, "html-webpack-plugin": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-5.5.0.tgz", - "integrity": "sha512-sy88PC2cRTVxvETRgUHFrL4No3UxvcH8G1NepGhqaTT+GXN2kTamqasot0inS5hXeg1cMbFDt27zzo9p35lZVw==", + "version": "5.5.3", + "resolved": "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-5.5.3.tgz", + "integrity": "sha512-6YrDKTuqaP/TquFH7h4srYWsZx+x6k6+FbsTm0ziCwGHDP78Unr1r9F/H4+sGmMbX08GQcJ+K64x55b+7VM/jg==", "requires": { "@types/html-minifier-terser": "^6.0.0", "html-minifier-terser": "^6.0.2", @@ -18792,20 +19498,20 @@ } }, "htmlparser2": { - "version": "8.0.1", - "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.1.tgz", - "integrity": "sha512-4lVbmc1diZC7GUJQtRQ5yBAeUCL1exyMwmForWkRLnwyzWBFxN633SALPMGYaWZvKe9j1pRZJpauvmxENSp/EA==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.1.0.tgz", + "integrity": "sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==", "requires": { - "domelementtype": "^2.3.0", - "domhandler": "^5.0.2", - "domutils": "^3.0.1", - "entities": "^4.3.0" + "domelementtype": "^2.0.1", + "domhandler": "^4.0.0", + "domutils": "^2.5.2", + "entities": "^2.0.0" }, "dependencies": { "entities": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/entities/-/entities-4.3.1.tgz", - "integrity": "sha512-o4q/dYJlmyjP2zfnaWDUC6A3BQFmVTX+tZPezK7k0GLSU9QYCauscf5Y+qcEPzKL+EixVouYDgLQK5H9GrLpkg==" + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", + "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==" } } }, @@ -18847,22 +19553,15 @@ } }, "http-proxy-middleware": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.6.tgz", - "integrity": "sha512-ya/UeJ6HVBYxrgYotAZo1KvPWlgB48kUJLDePFeneHsVujFaW5WNj2NgWCAE//B1Dl02BIfYlpNgBy8Kf8Rjmw==", + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.7.tgz", + "integrity": "sha512-fgVY8AV7qU7z/MmXJ/rxwbrtQH4jBQ9m7kp3llF0liB7glmFeVZFBepQb32T3y8n8k2+AEYuMPCpinYW+/CuRA==", "requires": { "@types/http-proxy": "^1.17.8", "http-proxy": "^1.18.1", "is-glob": "^4.0.1", "is-plain-obj": "^3.0.0", "micromatch": "^4.0.2" - }, - "dependencies": { - "is-plain-obj": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-3.0.0.tgz", - "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==" - } } }, "human-signals": { @@ -18890,9 +19589,9 @@ "integrity": "sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==" }, "image-size": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/image-size/-/image-size-1.0.2.tgz", - "integrity": "sha512-xfOoWjceHntRb3qFCrh5ZFORYH8XCdYpASltMhZ/Q0KZiOwjdE/Yl2QCiWdwD+lygV5bMCvauzgu5PxBX/Yerg==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/image-size/-/image-size-1.1.1.tgz", + "integrity": "sha512-541xKlUw6jr/6gGuk92F+mYM5zaFAc5ahphvkqvNe2bQ6gVBkd6bfrmVJ2t4KDAfikAYZyIqTnktX3i6/aQDrQ==", "requires": { "queue": "6.0.2" } @@ -18975,9 +19674,9 @@ } }, "ipaddr.js": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.0.1.tgz", - "integrity": "sha512-1qTgH9NG+IIJ4yfKs2e6Pp1bZg8wbDbKHT21HrLIeYBTRLgMYKnMTPAuI3Lcs61nfx5h1xlXnbJtH1kX5/d/ng==" + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.1.0.tgz", + "integrity": "sha512-LlbxQ7xKzfBusov6UMi4MFpEg0m+mAm9xyNGEduwXMEDuf4WfzB/RZwMVYEd7IKGvh4IUkEXYxtAVu9T3OelJQ==" }, "is-alphabetical": { "version": "1.0.4", @@ -19017,6 +19716,13 @@ "integrity": "sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w==", "requires": { "ci-info": "^2.0.0" + }, + "dependencies": { + "ci-info": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz", + "integrity": "sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==" + } } }, "is-core-module": { @@ -19100,9 +19806,9 @@ "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==" }, "is-plain-obj": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", - "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==" + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-3.0.0.tgz", + "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==" }, "is-plain-object": { "version": "2.0.4", @@ -19170,6 +19876,19 @@ "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==" }, + "jest-util": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-29.7.0.tgz", + "integrity": "sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==", + "requires": { + "@jest/types": "^29.6.3", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + } + }, "jest-worker": { "version": "27.5.1", "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz", @@ -19190,15 +19909,20 @@ } } }, + "jiti": { + "version": "1.21.0", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.0.tgz", + "integrity": "sha512-gFqAIbuKyyso/3G2qhiO2OM6shY6EPP/R0+mkDbyspxKazh8BXDC5FiFsUjlczgdNz/vfra0da2y+aHrusLG/Q==" + }, "joi": { - "version": "17.6.0", - "resolved": "https://registry.npmjs.org/joi/-/joi-17.6.0.tgz", - "integrity": "sha512-OX5dG6DTbcr/kbMFj0KGYxuew69HPcAE3K/sZpEV2nP6e/j/C0HV+HNiBPCASxdx5T7DMoa0s8UeHWMnb6n2zw==", + "version": "17.11.0", + "resolved": "https://registry.npmjs.org/joi/-/joi-17.11.0.tgz", + "integrity": "sha512-NgB+lZLNoqISVy1rZocE9PZI36bL/77ie924Ri43yEvi9GUUMPeyVIr8KdFTMUlby1p0PBYMk9spIxEUQYqrJQ==", "requires": { "@hapi/hoek": "^9.0.0", "@hapi/topo": "^5.0.0", "@sideway/address": "^4.1.3", - "@sideway/formula": "^3.0.0", + "@sideway/formula": "^3.0.1", "@sideway/pinpoint": "^2.0.0" } }, @@ -19280,15 +20004,24 @@ "package-json": "^6.3.0" } }, + "launch-editor": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/launch-editor/-/launch-editor-2.6.1.tgz", + "integrity": "sha512-eB/uXmFVpY4zezmGp5XtU21kwo7GBbKB+EQ+UZeWtGb9yAM5xt/Evk+lYH3eRNAtId+ej4u7TYPFZ07w4s7rRw==", + "requires": { + "picocolors": "^1.0.0", + "shell-quote": "^1.8.1" + } + }, "leven": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==" }, "lilconfig": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.0.6.tgz", - "integrity": "sha512-9JROoBW7pobfsx+Sq2JsASvCo6Pfo6WWoUW79HuB1BCoBXD4PLWJPqDF6fNj67pqBYTbAHkE57M1kS/+L1neOg==" + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz", + "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==" }, "lines-and-columns": { "version": "1.2.4", @@ -19394,9 +20127,9 @@ }, "dependencies": { "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==" } } }, @@ -19465,9 +20198,9 @@ } }, "merge-descriptors": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz", - "integrity": "sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==" + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==" }, "merge-stream": { "version": "2.0.0", @@ -19485,11 +20218,11 @@ "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==" }, "micromatch": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", - "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", "requires": { - "braces": "^3.0.2", + "braces": "^3.0.3", "picomatch": "^2.3.1" } }, @@ -19521,58 +20254,12 @@ "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz", "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==" }, - "mini-create-react-context": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/mini-create-react-context/-/mini-create-react-context-0.4.1.tgz", - "integrity": "sha512-YWCYEmd5CQeHGSAKrYvXgmzzkrvssZcuuQDDeqkT+PziKGMgE+0MCCtcKbROzocGBG1meBLl2FotlRwf4gAzbQ==", - "requires": { - "@babel/runtime": "^7.12.1", - "tiny-warning": "^1.0.3" - } - }, "mini-css-extract-plugin": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.6.1.tgz", - "integrity": "sha512-wd+SD57/K6DiV7jIR34P+s3uckTRuQvx0tKPcvjFlrEylk6P4mQ2KSWk1hblj1Kxaqok7LogKOieygXqBczNlg==", + "version": "2.7.6", + "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.7.6.tgz", + "integrity": "sha512-Qk7HcgaPkGG6eD77mLvZS1nmxlao3j+9PkrT9Uc7HAE1id3F41+DdBRYRYkbyfNRGzm8/YWtzhw7nVPmwhqTQw==", "requires": { "schema-utils": "^4.0.0" - }, - "dependencies": { - "ajv": { - "version": "8.11.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz", - "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==", - "requires": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - } - }, - "ajv-keywords": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", - "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", - "requires": { - "fast-deep-equal": "^3.1.3" - } - }, - "json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" - }, - "schema-utils": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", - "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", - "requires": { - "@types/json-schema": "^7.0.9", - "ajv": "^8.8.0", - "ajv-formats": "^2.1.1", - "ajv-keywords": "^5.0.0" - } - } } }, "minimalistic-assert": { @@ -19589,9 +20276,9 @@ } }, "minimist": { - "version": "1.2.6", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz", - "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==" + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==" }, "mrmime": { "version": "1.0.1", @@ -19613,9 +20300,9 @@ } }, "nanoid": { - "version": "3.3.4", - "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.4.tgz", - "integrity": "sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw==" + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz", + "integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==" }, "negotiator": { "version": "0.6.3", @@ -19645,9 +20332,9 @@ } }, "node-fetch": { - "version": "2.6.7", - "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz", - "integrity": "sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==", + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", + "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==", "requires": { "whatwg-url": "^5.0.0" } @@ -19658,9 +20345,9 @@ "integrity": "sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==" }, "node-releases": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.6.tgz", - "integrity": "sha512-PiVXnNuFm5+iYkLBNeq5211hvO38y63T0i2KKh2KnUs3RpzJ+JtODFjkD8yjLwnDkTYF1eKXheUwdssR+NRZdg==" + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.14.tgz", + "integrity": "sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==" }, "normalize-path": { "version": "3.0.0", @@ -19704,9 +20391,9 @@ "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==" }, "object-inspect": { - "version": "1.12.2", - "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.2.tgz", - "integrity": "sha512-z+cPxW0QGUp0mcqcsgQyLVRDoXFQbXOwBaqyF7VIgI4TWNQsDHrBpUQslRmIfAoYWdYzs6UlKJtB2XJpTaNSpQ==" + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.2.tgz", + "integrity": "sha512-IRZSRuzJiynemAXPYtPe5BoI/RESNYR7TYm50MC5Mqbd3Jmw5y790sErYw3V6SryFJD64b74qQQs9wn5Bg/k3g==" }, "object-keys": { "version": "1.1.1", @@ -19833,9 +20520,9 @@ }, "dependencies": { "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==" } } }, @@ -19886,18 +20573,11 @@ "integrity": "sha512-twN+njEipszzlMJd4ONUYgSfZPDxgHhT9Ahed5uTigpQn90FggW4SA/AIPq/6a149fTbE9qBEcSwE3FAEp6wQQ==" }, "parse5": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.0.0.tgz", - "integrity": "sha512-y/t8IXSPWTuRZqXc0ajH/UwDj4mnqLEbSttNbThcFhGrZuOyoyvNBO85PBp2jQa55wY9d07PBNjsK8ZP3K5U6g==", + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.1.2.tgz", + "integrity": "sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==", "requires": { - "entities": "^4.3.0" - }, - "dependencies": { - "entities": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/entities/-/entities-4.3.1.tgz", - "integrity": "sha512-o4q/dYJlmyjP2zfnaWDUC6A3BQFmVTX+tZPezK7k0GLSU9QYCauscf5Y+qcEPzKL+EixVouYDgLQK5H9GrLpkg==" - } + "entities": "^4.4.0" } }, "parse5-htmlparser2-tree-adapter": { @@ -19907,6 +20587,16 @@ "requires": { "domhandler": "^5.0.2", "parse5": "^7.0.0" + }, + "dependencies": { + "domhandler": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "requires": { + "domelementtype": "^2.3.0" + } + } } }, "parseurl": { @@ -20020,11 +20710,11 @@ } }, "postcss": { - "version": "8.4.14", - "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.14.tgz", - "integrity": "sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==", + "version": "8.4.31", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.31.tgz", + "integrity": "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==", "requires": { - "nanoid": "^3.3.4", + "nanoid": "^3.3.6", "picocolors": "^1.0.0", "source-map-js": "^1.0.2" } @@ -20039,22 +20729,22 @@ } }, "postcss-colormin": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-5.3.0.tgz", - "integrity": "sha512-WdDO4gOFG2Z8n4P8TWBpshnL3JpmNmJwdnfP2gbk2qBA8PWwOYcmjmI/t3CmMeL72a7Hkd+x/Mg9O2/0rD54Pg==", + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-5.3.1.tgz", + "integrity": "sha512-UsWQG0AqTFQmpBegeLLc1+c3jIqBNB0zlDGRWR+dQ3pRKJL1oeMzyqmH3o2PIfn9MBdNrVPWhDbT769LxCTLJQ==", "requires": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "caniuse-api": "^3.0.0", "colord": "^2.9.1", "postcss-value-parser": "^4.2.0" } }, "postcss-convert-values": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-5.1.2.tgz", - "integrity": "sha512-c6Hzc4GAv95B7suy4udszX9Zy4ETyMCgFPUDtWjdFTKH1SE9eFY/jEpHSwTH1QPuwxHpWslhckUQWbNRM4ho5g==", + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-5.1.3.tgz", + "integrity": "sha512-82pC1xkJZtcJEfiLw6UXnXVXScgtBrjlO5CBmuDQc+dlb88ZYheFsjTn40+zBVi3DkfF7iezO0nJUPLcJK3pvA==", "requires": { - "browserslist": "^4.20.3", + "browserslist": "^4.21.4", "postcss-value-parser": "^4.2.0" } }, @@ -20091,13 +20781,26 @@ } }, "postcss-loader": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/postcss-loader/-/postcss-loader-7.0.1.tgz", - "integrity": "sha512-VRviFEyYlLjctSM93gAZtcJJ/iSkPZ79zWbN/1fSH+NisBByEiVLqpdVDrPLVSi8DX0oJo12kL/GppTBdKVXiQ==", + "version": "7.3.3", + "resolved": "https://registry.npmjs.org/postcss-loader/-/postcss-loader-7.3.3.tgz", + "integrity": "sha512-YgO/yhtevGO/vJePCQmTxiaEwER94LABZN0ZMT4A0vsak9TpO+RvKRs7EmJ8peIlB9xfXCsS7M8LjqncsUZ5HA==", "requires": { - "cosmiconfig": "^7.0.0", - "klona": "^2.0.5", - "semver": "^7.3.7" + "cosmiconfig": "^8.2.0", + "jiti": "^1.18.2", + "semver": "^7.3.8" + }, + "dependencies": { + "cosmiconfig": { + "version": "8.3.6", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-8.3.6.tgz", + "integrity": "sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==", + "requires": { + "import-fresh": "^3.3.0", + "js-yaml": "^4.1.0", + "parse-json": "^5.2.0", + "path-type": "^4.0.0" + } + } } }, "postcss-merge-idents": { @@ -20110,20 +20813,20 @@ } }, "postcss-merge-longhand": { - "version": "5.1.6", - "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-5.1.6.tgz", - "integrity": "sha512-6C/UGF/3T5OE2CEbOuX7iNO63dnvqhGZeUnKkDeifebY0XqkkvrctYSZurpNE902LDf2yKwwPFgotnfSoPhQiw==", + "version": "5.1.7", + "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-5.1.7.tgz", + "integrity": "sha512-YCI9gZB+PLNskrK0BB3/2OzPnGhPkBEwmwhfYk1ilBHYVAZB7/tkTHFBAnCrvBBOmeYyMYw3DMjT55SyxMBzjQ==", "requires": { "postcss-value-parser": "^4.2.0", - "stylehacks": "^5.1.0" + "stylehacks": "^5.1.1" } }, "postcss-merge-rules": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-5.1.2.tgz", - "integrity": "sha512-zKMUlnw+zYCWoPN6yhPjtcEdlJaMUZ0WyVcxTAmw3lkkN/NDMRkOkiuctQEoWAOvH7twaxUUdvBWl0d4+hifRQ==", + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-5.1.4.tgz", + "integrity": "sha512-0R2IuYpgU93y9lhVbO/OylTtKMVcHb67zjWIfCiKR9rWL3GUk1677LAqD/BcHizukdZEjT8Ru3oHRoAYoJy44g==", "requires": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "caniuse-api": "^3.0.0", "cssnano-utils": "^3.1.0", "postcss-selector-parser": "^6.0.5" @@ -20148,11 +20851,11 @@ } }, "postcss-minify-params": { - "version": "5.1.3", - "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-5.1.3.tgz", - "integrity": "sha512-bkzpWcjykkqIujNL+EVEPOlLYi/eZ050oImVtHU7b4lFS82jPnsCb44gvC6pxaNt38Els3jWYDHTjHKf0koTgg==", + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-5.1.4.tgz", + "integrity": "sha512-+mePA3MgdmVmv6g+30rn57USjOGSAyuxUmkfiWpzalZ8aiBkdPYjXWtHuwJGm1v5Ojy0Z0LaSYhHaLJQB0P8Jw==", "requires": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "cssnano-utils": "^3.1.0", "postcss-value-parser": "^4.2.0" } @@ -20172,9 +20875,9 @@ "requires": {} }, "postcss-modules-local-by-default": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.0.0.tgz", - "integrity": "sha512-sT7ihtmGSF9yhm6ggikHdV0hlziDTX7oFoXtuVWeDd3hHObNkcHRo9V3yg7vCAY7cONyxJC/XXCmmiHHcvX7bQ==", + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.0.3.tgz", + "integrity": "sha512-2/u2zraspoACtrbFRnTijMiQtb4GW4BvatjaG/bCjYQo8kLTdevCUlwuBHx2sCnSyrI3x3qj4ZK1j5LQBgzmwA==", "requires": { "icss-utils": "^5.0.0", "postcss-selector-parser": "^6.0.2", @@ -20244,11 +20947,11 @@ } }, "postcss-normalize-unicode": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-5.1.0.tgz", - "integrity": "sha512-J6M3MizAAZ2dOdSjy2caayJLQT8E8K9XjLce8AUQMwOrCvjCHv24aLC/Lps1R1ylOfol5VIDMaM/Lo9NGlk1SQ==", + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-5.1.1.tgz", + "integrity": "sha512-qnCL5jzkNUmKVhZoENp1mJiGNPcsJCs1aaRmURmeJGES23Z/ajaln+EPTD+rBeNkSryI+2WTdW+lwcVdOikrpA==", "requires": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "postcss-value-parser": "^4.2.0" } }, @@ -20287,11 +20990,11 @@ } }, "postcss-reduce-initial": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-5.1.0.tgz", - "integrity": "sha512-5OgTUviz0aeH6MtBjHfbr57tml13PuedK/Ecg8szzd4XRMbYxH4572JFG067z+FqBIf6Zp/d+0581glkvvWMFw==", + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-5.1.2.tgz", + "integrity": "sha512-dE/y2XRaqAi6OvjzD22pjTUQ8eOfc6m/natGHgKFBK9DxFmIm69YmaRVQrGgFlEfc1HePIurY0TmDeROK05rIg==", "requires": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "caniuse-api": "^3.0.0" } }, @@ -20304,20 +21007,20 @@ } }, "postcss-selector-parser": { - "version": "6.0.10", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz", - "integrity": "sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==", + "version": "6.0.13", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.13.tgz", + "integrity": "sha512-EaV1Gl4mUEV4ddhDnv/xtj7sxwrwxdetHdWUGnT4VJQf+4d05v6lHYZr8N573k5Z0BViss7BDhfWtKS3+sfAqQ==", "requires": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "postcss-sort-media-queries": { - "version": "4.2.1", - "resolved": "https://registry.npmjs.org/postcss-sort-media-queries/-/postcss-sort-media-queries-4.2.1.tgz", - "integrity": "sha512-9VYekQalFZ3sdgcTjXMa0dDjsfBVHXlraYJEMiOJ/2iMmI2JGCMavP16z3kWOaRu8NSaJCTgVpB/IVpH5yT9YQ==", + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/postcss-sort-media-queries/-/postcss-sort-media-queries-4.4.1.tgz", + "integrity": "sha512-QDESFzDDGKgpiIh4GYXsSy6sek2yAwQx1JASl5AxBtU1Lq2JfKBljIPNdil989NcSKRQX1ToiaKphImtBuhXWw==", "requires": { - "sort-css-media-queries": "2.0.4" + "sort-css-media-queries": "2.1.0" } }, "postcss-svgo": { @@ -20374,9 +21077,9 @@ "requires": {} }, "prismjs": { - "version": "1.28.0", - "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.28.0.tgz", - "integrity": "sha512-8aaXdYvl1F7iC7Xm1spqSaY/OJBpYW3v+KJ+F17iYxvdc8sfjW194COK5wVhMZX45tGteiBQgdvD/nhxcRwylw==" + "version": "1.29.0", + "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.29.0.tgz", + "integrity": "sha512-Kx/1w86q/epKcmte75LNrEoT+lX8pBpavuAbvJWRXar7Hz8jrtF+e3vY751p0R8H9HdArwaCTNDDzHg/ScJK1Q==" }, "process-nextick-args": { "version": "2.0.1", @@ -20462,11 +21165,11 @@ "integrity": "sha512-QFADYnsVoBMw1srW7OVKEYjG+MbIa49s54w1MA1EDY6r2r/sTcKKYqRX1f4GYvnXP7eN/Pe9HFcX+hwzmrXRHA==" }, "qs": { - "version": "6.10.3", - "resolved": "https://registry.npmjs.org/qs/-/qs-6.10.3.tgz", - "integrity": "sha512-wr7M2E0OFRfIfJZjKGieI8lBKb7fRCH4Fv5KNPEs7gJ8jadvotdsS08PzOKR7opXhZ/Xkjtt3WF9g38drmyRqQ==", + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz", + "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==", "requires": { - "side-channel": "^1.0.4" + "side-channel": "^1.0.6" } }, "queue": { @@ -20496,9 +21199,9 @@ "integrity": "sha512-kA5WQoNVo4t9lNx2kQNFCxKeBl5IbbSNBl1M/tLkw9WCn+hxNBAW5Qh8gdhs63CJnhjJ2zQWFoqPJP2sK1AV5A==" }, "raw-body": { - "version": "2.5.1", - "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.1.tgz", - "integrity": "sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==", + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz", + "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==", "requires": { "bytes": "3.1.2", "http-errors": "2.0.0", @@ -20730,15 +21433,14 @@ } }, "react-router": { - "version": "5.3.3", - "resolved": "https://registry.npmjs.org/react-router/-/react-router-5.3.3.tgz", - "integrity": "sha512-mzQGUvS3bM84TnbtMYR8ZjKnuPJ71IjSzR+DE6UkUqvN4czWIqEs17yLL8xkAycv4ev0AiN+IGrWu88vJs/p2w==", + "version": "5.3.4", + "resolved": "https://registry.npmjs.org/react-router/-/react-router-5.3.4.tgz", + "integrity": "sha512-Ys9K+ppnJah3QuaRiLxk+jDWOR1MekYQrlytiXxC1RyfbdsZkS5pvKAzCCr031xHixZwpnsYNT5xysdFHQaYsA==", "requires": { "@babel/runtime": "^7.12.13", "history": "^4.9.0", "hoist-non-react-statics": "^3.1.0", "loose-envify": "^1.3.1", - "mini-create-react-context": "^0.4.0", "path-to-regexp": "^1.7.0", "prop-types": "^15.6.2", "react-is": "^16.6.0", @@ -20755,15 +21457,15 @@ } }, "react-router-dom": { - "version": "5.3.3", - "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-5.3.3.tgz", - "integrity": "sha512-Ov0tGPMBgqmbu5CDmN++tv2HQ9HlWDuWIIqn4b88gjlAN5IHI+4ZUZRcpz9Hl0azFIwihbLDYw1OiHGRo7ZIng==", + "version": "5.3.4", + "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-5.3.4.tgz", + "integrity": "sha512-m4EqFMHv/Ih4kpcBCONHbkT68KoAeHN4p3lAGoNryfHi0dMy0kCzEZakiKRsvg5wHZ/JLrLW8o8KomWiz/qbYQ==", "requires": { "@babel/runtime": "^7.12.13", "history": "^4.9.0", "loose-envify": "^1.3.1", "prop-types": "^15.6.2", - "react-router": "5.3.3", + "react-router": "5.3.4", "tiny-invariant": "^1.0.2", "tiny-warning": "^1.0.0" } @@ -20775,19 +21477,19 @@ "requires": {} }, "react-textarea-autosize": { - "version": "8.3.4", - "resolved": "https://registry.npmjs.org/react-textarea-autosize/-/react-textarea-autosize-8.3.4.tgz", - "integrity": "sha512-CdtmP8Dc19xL8/R6sWvtknD/eCXkQr30dtvC4VmGInhRsfF8X/ihXCq6+9l9qbxmKRiq407/7z5fxE7cVWQNgQ==", + "version": "8.5.3", + "resolved": "https://registry.npmjs.org/react-textarea-autosize/-/react-textarea-autosize-8.5.3.tgz", + "integrity": "sha512-XT1024o2pqCuZSuBt9FwHlaDeNtVrtCXu0Rnz88t1jUGheCLa3PhjE1GH8Ctm2axEtvdCl5SUHYschyQ0L5QHQ==", "requires": { - "@babel/runtime": "^7.10.2", + "@babel/runtime": "^7.20.13", "use-composed-ref": "^1.3.0", "use-latest": "^1.2.1" } }, "readable-stream": { - "version": "3.6.0", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz", - "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==", + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", "requires": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", @@ -20829,37 +21531,37 @@ "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==" }, "regenerate-unicode-properties": { - "version": "10.0.1", - "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.0.1.tgz", - "integrity": "sha512-vn5DU6yg6h8hP/2OkQo3K7uVILvY4iu0oI4t3HFa81UPkhGJwkRwM10JEc3upjdhHjs/k8GJY1sRBhk5sr69Bw==", + "version": "10.1.1", + "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.1.1.tgz", + "integrity": "sha512-X007RyZLsCJVVrjgEFVpLUTZwyOZk3oiL75ZcuYjlIWd6rNJtOjkBwQc5AsRrpbKVkxN6sklw/k/9m2jJYOf8Q==", "requires": { "regenerate": "^1.4.2" } }, "regenerator-runtime": { - "version": "0.13.9", - "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.9.tgz", - "integrity": "sha512-p3VT+cOEgxFsRRA9X4lkI1E+k2/CtnKtU4gcxyaCUreilL/vqI6CdZ3wxVUx3UOUg+gnUOQQcRI7BmSI656MYA==" + "version": "0.14.0", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.0.tgz", + "integrity": "sha512-srw17NI0TUWHuGa5CFGGmhfNIeja30WMBfbslPNhf6JrqQlLN5gcrvig1oqPxiVaXb0oW0XRKtH6Nngs5lKCIA==" }, "regenerator-transform": { - "version": "0.15.0", - "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.15.0.tgz", - "integrity": "sha512-LsrGtPmbYg19bcPHwdtmXwbW+TqNvtY4riE3P83foeHRroMbH6/2ddFBfab3t7kbzc7v7p4wbkIecHImqt0QNg==", + "version": "0.15.2", + "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.15.2.tgz", + "integrity": "sha512-hfMp2BoF0qOk3uc5V20ALGDS2ddjQaLrdl7xrGXvAIow7qeWRM2VA2HuCHkUKk9slq3VwEwLNK3DFBqDfPGYtg==", "requires": { "@babel/runtime": "^7.8.4" } }, "regexpu-core": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-5.1.0.tgz", - "integrity": "sha512-bb6hk+xWd2PEOkj5It46A16zFMs2mv86Iwpdu94la4S3sJ7C973h2dHpYKwIBGaWSO7cIRJ+UX0IeMaWcO4qwA==", + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-5.3.2.tgz", + "integrity": "sha512-RAM5FlZz+Lhmo7db9L298p2vHP5ZywrVXmVXpmAD9GuL5MPH6t9ROw1iA/wfHkQ76Qe7AaPF0nGuim96/IrQMQ==", "requires": { + "@babel/regjsgen": "^0.8.0", "regenerate": "^1.4.2", - "regenerate-unicode-properties": "^10.0.1", - "regjsgen": "^0.6.0", - "regjsparser": "^0.8.2", + "regenerate-unicode-properties": "^10.1.0", + "regjsparser": "^0.9.1", "unicode-match-property-ecmascript": "^2.0.0", - "unicode-match-property-value-ecmascript": "^2.0.0" + "unicode-match-property-value-ecmascript": "^2.1.0" } }, "registry-auth-token": { @@ -20879,14 +21581,14 @@ } }, "regjsgen": { - "version": "0.6.0", - "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.6.0.tgz", - "integrity": "sha512-ozE883Uigtqj3bx7OhL1KNbCzGyW2NQZPl6Hs09WTvCuZD5sTI4JY58bkbQWa/Y9hxIsvJ3M8Nbf7j54IqeZbA==" + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.2.tgz", + "integrity": "sha512-OFFT3MfrH90xIW8OOSyUrk6QHD5E9JOTeGodiJeBS3J6IwlgzJMNE/1bZklWz5oTg+9dCMyEetclvCVXOPoN3A==" }, "regjsparser": { - "version": "0.8.4", - "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.8.4.tgz", - "integrity": "sha512-J3LABycON/VNEu3abOviqGHuB/LOtOQj8SKmfP9anY5GfAVw/SPjwzSjxGjbZXIxbGfqTHtJw58C2Li/WkStmA==", + "version": "0.9.1", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.9.1.tgz", + "integrity": "sha512-dQUtn90WanSNl+7mQKcXAgZxvUe7Z0SqXlgzv0za4LwiUhyzBC58yQO3liFoUgu8GiJVInAhJjkj1N0EtQ5nkQ==", "requires": { "jsesc": "~0.5.0" }, @@ -20970,16 +21672,6 @@ "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.10.4.tgz", "integrity": "sha512-O4KCvQA6lLiMU9l2eawBPMf1xPP8xPfB3iEQw150hOVTqj/rfXz0ThTb4HEzqQfs2Bmo5Ay8BzxfzVtBrr9dVg==" }, - "@babel/plugin-proposal-object-rest-spread": { - "version": "7.12.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.12.1.tgz", - "integrity": "sha512-s6SowJIjzlhx8o7lsFx5zmY4At6CTtDvgNQDdPzkBQucle58A6b/TTeEBYtyDgmcXjUTM+vE8YOGHZzzbc/ioA==", - "requires": { - "@babel/helper-plugin-utils": "^7.10.4", - "@babel/plugin-syntax-object-rest-spread": "^7.8.0", - "@babel/plugin-transform-parameters": "^7.12.1" - } - }, "@babel/plugin-syntax-jsx": { "version": "7.12.1", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.12.1.tgz", @@ -20988,10 +21680,20 @@ "@babel/helper-plugin-utils": "^7.10.4" } }, + "convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==" + }, + "is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==" + }, "semver": { - "version": "5.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", - "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==" + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", + "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==" }, "source-map": { "version": "0.5.7", @@ -21054,64 +21756,6 @@ "htmlparser2": "^6.1.0", "lodash": "^4.17.21", "strip-ansi": "^6.0.1" - }, - "dependencies": { - "css-select": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz", - "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==", - "requires": { - "boolbase": "^1.0.0", - "css-what": "^6.0.1", - "domhandler": "^4.3.1", - "domutils": "^2.8.0", - "nth-check": "^2.0.1" - } - }, - "dom-serializer": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz", - "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==", - "requires": { - "domelementtype": "^2.0.1", - "domhandler": "^4.2.0", - "entities": "^2.0.0" - } - }, - "domhandler": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz", - "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==", - "requires": { - "domelementtype": "^2.2.0" - } - }, - "domutils": { - "version": "2.8.0", - "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz", - "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==", - "requires": { - "dom-serializer": "^1.0.1", - "domelementtype": "^2.2.0", - "domhandler": "^4.2.0" - } - }, - "entities": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", - "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==" - }, - "htmlparser2": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.1.0.tgz", - "integrity": "sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==", - "requires": { - "domelementtype": "^2.0.1", - "domhandler": "^4.0.0", - "domutils": "^2.5.2", - "entities": "^2.0.0" - } - } } }, "repeat-string": { @@ -21240,9 +21884,9 @@ } }, "rxjs": { - "version": "7.5.6", - "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.5.6.tgz", - "integrity": "sha512-dnyv2/YsXhnm461G+R/Pe5bWP41Nm6LBXEYWI6eiFP4fiwx6WRI/CD0zbdVAudd9xwLEF2IDcKXLHit0FYjUzw==", + "version": "7.8.1", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.1.tgz", + "integrity": "sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==", "requires": { "tslib": "^2.1.0" } @@ -21293,9 +21937,9 @@ } }, "sax": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", - "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==" + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.3.0.tgz", + "integrity": "sha512-0s+oAmw9zLl1V1cS9BtZN7JAd0cW5e0QH4W3LWEK6a4LaLEA2OTpGYWDY+6XasBLtz6wkm3u1xRw95mRuJ59WA==" }, "scheduler": { "version": "0.19.1", @@ -21307,15 +21951,48 @@ } }, "schema-utils": { - "version": "2.7.1", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.1.tgz", - "integrity": "sha512-SHiNtMOUGWBQJwzISiVYKu82GiV4QYGePp3odlY1tuKO7gPtphAT5R/py0fA6xtbgLL/RvtJZnU9b8s0F1q0Xg==", + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.2.0.tgz", + "integrity": "sha512-L0jRsrPpjdckP3oPug3/VxNKt2trR8TcabrM6FOAAlvC/9Phcmm+cuAgTlxBqdBR1WJx7Naj9WHw+aOmheSVbw==", "requires": { - "@types/json-schema": "^7.0.5", - "ajv": "^6.12.4", - "ajv-keywords": "^3.5.2" + "@types/json-schema": "^7.0.9", + "ajv": "^8.9.0", + "ajv-formats": "^2.1.1", + "ajv-keywords": "^5.1.0" + }, + "dependencies": { + "ajv": { + "version": "8.12.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz", + "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==", + "requires": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + } + }, + "ajv-keywords": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", + "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "requires": { + "fast-deep-equal": "^3.1.3" + } + }, + "json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" + } } }, + "search-insights": { + "version": "2.13.0", + "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.13.0.tgz", + "integrity": "sha512-Orrsjf9trHHxFRuo9/rzm0KIWmgzE8RMlZMzuhZOJ01Rnz3D0YBAe+V6473t6/H6c7irs6Lt48brULAiRWb3Vw==", + "peer": true + }, "section-matter": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/section-matter/-/section-matter-1.0.0.tgz", @@ -21331,17 +22008,18 @@ "integrity": "sha512-mEugaLK+YfkijB4fx0e6kImuJdCIt2LxCRcbEYPqRGCs4F2ogyfZU5IAZRdjCP8JPq2AtdNoC/Dux63d9Kiryg==" }, "selfsigned": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-2.0.1.tgz", - "integrity": "sha512-LmME957M1zOsUhG+67rAjKfiWFox3SBxE/yymatMZsAx+oMrJ0YQ8AToOnyCm7xbeg2ep37IHLxdu0o2MavQOQ==", + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-2.4.1.tgz", + "integrity": "sha512-th5B4L2U+eGLq1TVh7zNRGBapioSORUeymIydxgFpwww9d2qyKvtuPU2jJuHvYAwwqi2Y596QBL3eEqcPEYL8Q==", "requires": { + "@types/node-forge": "^1.3.0", "node-forge": "^1" } }, "semver": { - "version": "7.3.7", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz", - "integrity": "sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==", + "version": "7.5.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz", + "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==", "requires": { "lru-cache": "^6.0.0" } @@ -21355,16 +22033,16 @@ }, "dependencies": { "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==" } } }, "send": { - "version": "0.18.0", - "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz", - "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==", + "version": "0.19.0", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz", + "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==", "requires": { "debug": "2.6.9", "depd": "2.0.0", @@ -21396,6 +22074,11 @@ } } }, + "encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==" + }, "ms": { "version": "2.1.3", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", @@ -21409,9 +22092,9 @@ } }, "serialize-javascript": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz", - "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==", + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.1.tgz", + "integrity": "sha512-owoXEFjWRllis8/M1Q+Cw5k8ZH40e3zhp/ovX+Xr/vi1qj6QesbyXXViFbpNvWvPNAD62SutwEXavefrLJWj7w==", "requires": { "randombytes": "^2.1.0" } @@ -21499,14 +22182,27 @@ } }, "serve-static": { - "version": "1.15.0", - "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz", - "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==", + "version": "1.16.2", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz", + "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==", "requires": { - "encodeurl": "~1.0.2", + "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "parseurl": "~1.3.3", - "send": "0.18.0" + "send": "0.19.0" + } + }, + "set-function-length": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz", + "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==", + "requires": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.2" } }, "setimmediate": { @@ -21546,9 +22242,9 @@ "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==" }, "shell-quote": { - "version": "1.7.3", - "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.7.3.tgz", - "integrity": "sha512-Vpfqwm4EnqGdlsBFNmHhxhElJYrdfcxPThu+ryKS5J8L/fhAwLazFZtq+S+TWZ9ANj2piSQLGj6NQg+lKPmxrw==" + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.1.tgz", + "integrity": "sha512-6j1W9l1iAs/4xYBI1SYOVZyFcCis9b4KCLQ8fgAGG07QvzaRLVVRQvAy85yNmmZSjYjg4MWh4gNvlPujU/5LpA==" }, "shelljs": { "version": "0.8.5", @@ -21561,13 +22257,14 @@ } }, "side-channel": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", - "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz", + "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==", "requires": { - "call-bind": "^1.0.0", - "get-intrinsic": "^1.0.2", - "object-inspect": "^1.9.0" + "call-bind": "^1.0.7", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.4", + "object-inspect": "^1.13.1" } }, "signal-exit": { @@ -21576,13 +22273,13 @@ "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==" }, "sirv": { - "version": "1.0.19", - "resolved": "https://registry.npmjs.org/sirv/-/sirv-1.0.19.tgz", - "integrity": "sha512-JuLThK3TnZG1TAKDwNIqNq6QA2afLOCcm+iE8D1Kj3GA40pSPsxQjjJl0J8X3tsR7T+CP1GavpzLwYkgVLWrZQ==", + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/sirv/-/sirv-2.0.3.tgz", + "integrity": "sha512-O9jm9BsID1P+0HOi81VpXPoDxYP374pkOLzACAoyUQ/3OUVndNpsz6wMnY2z+yOxzbllCKZrM+9QrWsv4THnyA==", "requires": { "@polka/url": "^1.0.0-next.20", "mrmime": "^1.0.0", - "totalist": "^1.0.0" + "totalist": "^3.0.0" } }, "sisteransi": { @@ -21624,9 +22321,9 @@ } }, "sort-css-media-queries": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/sort-css-media-queries/-/sort-css-media-queries-2.0.4.tgz", - "integrity": "sha512-PAIsEK/XupCQwitjv7XxoMvYhT7EAfyzI3hsy/MyDgTvc+Ft55ctdkctJLOy6cQejaIC+zjpUL4djFVm2ivOOw==" + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/sort-css-media-queries/-/sort-css-media-queries-2.1.0.tgz", + "integrity": "sha512-IeWvo8NkNiY2vVYdPa27MCQiR0MN0M80johAYFVxWWXQ44KU84WNxjslwBHmc/7ZL2ccwkM7/e6S5aiKZXm7jA==" }, "source-map": { "version": "0.6.1", @@ -21789,11 +22486,11 @@ } }, "stylehacks": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-5.1.0.tgz", - "integrity": "sha512-SzLmvHQTrIWfSgljkQCw2++C9+Ne91d/6Sp92I8c5uHTcy/PgeHamwITIbBW9wnFTY/3ZfSXR9HIL6Ikqmcu6Q==", + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-5.1.1.tgz", + "integrity": "sha512-sBpcd5Hx7G6seo7b1LkpttvTz7ikD0LlH5RmdcBNb6fFR0Fl7LQwHDFr300q4cwUqi+IYrFGmsIHieMBfnN/Bw==", "requires": { - "browserslist": "^4.16.6", + "browserslist": "^4.21.4", "postcss-selector-parser": "^6.0.4" } }, @@ -21833,51 +22530,6 @@ "version": "7.2.0", "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz", "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==" - }, - "css-select": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz", - "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==", - "requires": { - "boolbase": "^1.0.0", - "css-what": "^6.0.1", - "domhandler": "^4.3.1", - "domutils": "^2.8.0", - "nth-check": "^2.0.1" - } - }, - "dom-serializer": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz", - "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==", - "requires": { - "domelementtype": "^2.0.1", - "domhandler": "^4.2.0", - "entities": "^2.0.0" - } - }, - "domhandler": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz", - "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==", - "requires": { - "domelementtype": "^2.2.0" - } - }, - "domutils": { - "version": "2.8.0", - "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz", - "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==", - "requires": { - "dom-serializer": "^1.0.1", - "domelementtype": "^2.2.0", - "domhandler": "^4.2.0" - } - }, - "entities": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", - "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==" } } }, @@ -21887,20 +22539,20 @@ "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==" }, "terser": { - "version": "5.14.2", - "resolved": "https://registry.npmjs.org/terser/-/terser-5.14.2.tgz", - "integrity": "sha512-oL0rGeM/WFQCUd0y2QrWxYnq7tfSuKBiqTjRPWrRgB46WD/kiwHwF8T23z78H6Q6kGCuuHcPB+KULHRdxvVGQA==", + "version": "5.31.6", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.31.6.tgz", + "integrity": "sha512-PQ4DAriWzKj+qgehQ7LK5bQqCFNMmlhjR2PFFLuqGCpuCAauxemVBWwWOxo3UIwWQx8+Pr61Df++r76wDmkQBg==", "requires": { - "@jridgewell/source-map": "^0.3.2", - "acorn": "^8.5.0", + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.8.2", "commander": "^2.20.0", "source-map-support": "~0.5.20" }, "dependencies": { "acorn": { - "version": "8.7.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz", - "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==" + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz", + "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==" }, "commander": { "version": "2.20.3", @@ -21910,15 +22562,15 @@ } }, "terser-webpack-plugin": { - "version": "5.3.3", - "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.3.tgz", - "integrity": "sha512-Fx60G5HNYknNTNQnzQ1VePRuu89ZVYWfjRAeT5rITuCY/1b08s49e5kSQwHDirKZWuoKOBRFS98EUUoZ9kLEwQ==", + "version": "5.3.10", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz", + "integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==", "requires": { - "@jridgewell/trace-mapping": "^0.3.7", + "@jridgewell/trace-mapping": "^0.3.20", "jest-worker": "^27.4.5", "schema-utils": "^3.1.1", - "serialize-javascript": "^6.0.0", - "terser": "^5.7.2" + "serialize-javascript": "^6.0.1", + "terser": "^5.26.0" }, "dependencies": { "schema-utils": { @@ -21994,9 +22646,9 @@ "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==" }, "totalist": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/totalist/-/totalist-1.1.0.tgz", - "integrity": "sha512-gduQwd1rOdDMGxFG1gEvhV88Oirdo2p+KjoYFU7k2g+i7n6AFFbDQ5kMPUsW0pNbfQsB/cwXvT1i4Bue0s9g5g==" + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz", + "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==" }, "tr46": { "version": "0.0.3", @@ -22019,9 +22671,9 @@ "integrity": "sha512-rvuRbTarPXmMb79SmzEp8aqXNKcK+y0XaB298IXueQ8I2PsrATcPBCSPyK/dDNa2iWOhKlfNnOjdAOTBU/nkFA==" }, "tslib": { - "version": "2.4.0", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz", - "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==" + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz", + "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==" }, "type-fest": { "version": "2.16.0", @@ -22061,15 +22713,15 @@ } }, "typescript": { - "version": "4.7.4", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.7.4.tgz", - "integrity": "sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ==", + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz", + "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==", "peer": true }, "ua-parser-js": { - "version": "0.7.33", - "resolved": "https://registry.npmjs.org/ua-parser-js/-/ua-parser-js-0.7.33.tgz", - "integrity": "sha512-s8ax/CeZdK9R/56Sui0WM6y9OFREJarMRHqLB2EwkovemBxNQ+Bqu8GAsUnVcXKgphb++ghr/B2BZx4mahujPw==" + "version": "1.0.37", + "resolved": "https://registry.npmjs.org/ua-parser-js/-/ua-parser-js-1.0.37.tgz", + "integrity": "sha512-bhTyI94tZofjo+Dn8SN6Zv8nBDvyXTymAdM3LDI/0IboIUwTu1rEhW7v2TfiVsoYWgkQ4kOVqnI8APUFbIQIFQ==" }, "unescape": { "version": "1.0.1", @@ -22103,9 +22755,9 @@ } }, "unicode-match-property-value-ecmascript": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.0.0.tgz", - "integrity": "sha512-7Yhkc0Ye+t4PNYzOGKedDhXbYIBe1XEQYQxOPyhcXNMJ0WCABqqj6ckydd6pWRZTHV4GuCPKdBAUiMc60tsKVw==" + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.1.0.tgz", + "integrity": "sha512-qxkjQt6qjg/mYscYMC0XKRn3Rh0wFPlfxB0xkt9CfyTvpX1Ra0+rAmdX2QyAobptSEvuy4RtpPRui6XkV+8wjA==" }, "unicode-property-aliases-ecmascript": { "version": "2.0.0", @@ -22123,6 +22775,13 @@ "is-plain-obj": "^2.0.0", "trough": "^1.0.0", "vfile": "^4.0.0" + }, + "dependencies": { + "is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==" + } } }, "unique-string": { @@ -22207,9 +22866,9 @@ "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==" }, "update-browserslist-db": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.4.tgz", - "integrity": "sha512-jnmO2BEGUjsMOe/Fg9u0oczOe/ppIDZPebzccl1yDWGLFP16Pa1/RM5wEoKYPG2zstNcDuAStejyxsOuKINdGA==", + "version": "1.0.13", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.13.tgz", + "integrity": "sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==", "requires": { "escalade": "^3.1.1", "picocolors": "^1.0.0" @@ -22374,6 +23033,12 @@ "use-isomorphic-layout-effect": "^1.1.1" } }, + "use-sync-external-store": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.2.0.tgz", + "integrity": "sha512-eEgnFxGQ1Ife9bzYs6VLi8/4X6CObHMw9Qr9tPY43iKwsPw8xE8+EFsf/2cFZ5S3esXgpWgtSCtLNS41F+sKPA==", + "requires": {} + }, "util-deprecate": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", @@ -22452,9 +23117,9 @@ } }, "watchpack": { - "version": "2.4.0", - "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.0.tgz", - "integrity": "sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==", + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz", + "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==", "requires": { "glob-to-regexp": "^0.4.1", "graceful-fs": "^4.1.2" @@ -22479,45 +23144,44 @@ "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==" }, "webpack": { - "version": "5.76.1", - "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.76.1.tgz", - "integrity": "sha512-4+YIK4Abzv8172/SGqObnUjaIHjLEuUasz9EwQj/9xmPPkYJy2Mh03Q/lJfSD3YLzbxy5FeTq5Uw0323Oh6SJQ==", - "requires": { - "@types/eslint-scope": "^3.7.3", - "@types/estree": "^0.0.51", - "@webassemblyjs/ast": "1.11.1", - "@webassemblyjs/wasm-edit": "1.11.1", - "@webassemblyjs/wasm-parser": "1.11.1", + "version": "5.94.0", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz", + "integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==", + "requires": { + "@types/estree": "^1.0.5", + "@webassemblyjs/ast": "^1.12.1", + "@webassemblyjs/wasm-edit": "^1.12.1", + "@webassemblyjs/wasm-parser": "^1.12.1", "acorn": "^8.7.1", - "acorn-import-assertions": "^1.7.6", - "browserslist": "^4.14.5", + "acorn-import-attributes": "^1.9.5", + "browserslist": "^4.21.10", "chrome-trace-event": "^1.0.2", - "enhanced-resolve": "^5.10.0", - "es-module-lexer": "^0.9.0", + "enhanced-resolve": "^5.17.1", + "es-module-lexer": "^1.2.1", "eslint-scope": "5.1.1", "events": "^3.2.0", "glob-to-regexp": "^0.4.1", - "graceful-fs": "^4.2.9", + "graceful-fs": "^4.2.11", "json-parse-even-better-errors": "^2.3.1", "loader-runner": "^4.2.0", "mime-types": "^2.1.27", "neo-async": "^2.6.2", - "schema-utils": "^3.1.0", + "schema-utils": "^3.2.0", "tapable": "^2.1.1", - "terser-webpack-plugin": "^5.1.3", - "watchpack": "^2.4.0", + "terser-webpack-plugin": "^5.3.10", + "watchpack": "^2.4.1", "webpack-sources": "^3.2.3" }, "dependencies": { "acorn": { - "version": "8.7.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz", - "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==" + "version": "8.12.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz", + "integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==" }, - "acorn-import-assertions": { - "version": "1.8.0", - "resolved": "https://registry.npmjs.org/acorn-import-assertions/-/acorn-import-assertions-1.8.0.tgz", - "integrity": "sha512-m7VZ3jwz4eK6A4Vtt8Ew1/mNbP24u0FhdyfA7fSvnJR6LMdfOYnmuIrrJAgrYfYJ10F/otaHTtrtrtmHdMNzEw==", + "acorn-import-attributes": { + "version": "1.9.5", + "resolved": "https://registry.npmjs.org/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz", + "integrity": "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==", "requires": {} }, "mime-db": { @@ -22534,9 +23198,9 @@ } }, "schema-utils": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.1.1.tgz", - "integrity": "sha512-Y5PQxS4ITlC+EahLuXaY86TXfR7Dc5lw294alXOq86JAHCihAIZfqv8nNCWvaEJvaC51uN9hbLGeV0cFBdH+Fw==", + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz", + "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==", "requires": { "@types/json-schema": "^7.0.8", "ajv": "^6.12.5", @@ -22546,37 +23210,46 @@ } }, "webpack-bundle-analyzer": { - "version": "4.5.0", - "resolved": "https://registry.npmjs.org/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.5.0.tgz", - "integrity": "sha512-GUMZlM3SKwS8Z+CKeIFx7CVoHn3dXFcUAjT/dcZQQmfSZGvitPfMob2ipjai7ovFFqPvTqkEZ/leL4O0YOdAYQ==", + "version": "4.10.0", + "resolved": "https://registry.npmjs.org/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.10.0.tgz", + "integrity": "sha512-j+apH0Cs+FY8IOIwxLbkgEJnbQgEPEG8uqLVnRb9tAoGbyKNxQA1u9wNDrTQHK3PinO4Pckew7AE7pnX/RS3wA==", "requires": { + "@discoveryjs/json-ext": "0.5.7", "acorn": "^8.0.4", "acorn-walk": "^8.0.0", - "chalk": "^4.1.0", "commander": "^7.2.0", + "debounce": "^1.2.1", + "escape-string-regexp": "^4.0.0", "gzip-size": "^6.0.0", - "lodash": "^4.17.20", + "html-escaper": "^2.0.2", + "is-plain-object": "^5.0.0", "opener": "^1.5.2", - "sirv": "^1.0.7", + "picocolors": "^1.0.0", + "sirv": "^2.0.3", "ws": "^7.3.1" }, "dependencies": { "acorn": { - "version": "8.7.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz", - "integrity": "sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==" + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz", + "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==" }, "commander": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz", "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==" + }, + "is-plain-object": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz", + "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==" } } }, "webpack-dev-middleware": { - "version": "5.3.3", - "resolved": "https://registry.npmjs.org/webpack-dev-middleware/-/webpack-dev-middleware-5.3.3.tgz", - "integrity": "sha512-hj5CYrY0bZLB+eTO+x/j67Pkrquiy7kWepMHmUMoPsmcUaeEnQJqFzHJOyxgWlq746/wUuA64p9ta34Kyb01pA==", + "version": "5.3.4", + "resolved": "https://registry.npmjs.org/webpack-dev-middleware/-/webpack-dev-middleware-5.3.4.tgz", + "integrity": "sha512-BVdTqhhs+0IfoeAf7EoH5WE+exCmqGerHfDM0IL096Px60Tq2Mn9MAbnaGUe6HiMa41KMCYF19gyzZmBcq/o4Q==", "requires": { "colorette": "^2.0.10", "memfs": "^3.4.3", @@ -22585,30 +23258,6 @@ "schema-utils": "^4.0.0" }, "dependencies": { - "ajv": { - "version": "8.11.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz", - "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==", - "requires": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - } - }, - "ajv-keywords": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", - "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", - "requires": { - "fast-deep-equal": "^3.1.3" - } - }, - "json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" - }, "mime-db": { "version": "1.52.0", "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", @@ -22626,24 +23275,13 @@ "version": "1.2.1", "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==" - }, - "schema-utils": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", - "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", - "requires": { - "@types/json-schema": "^7.0.9", - "ajv": "^8.8.0", - "ajv-formats": "^2.1.1", - "ajv-keywords": "^5.0.0" - } } } }, "webpack-dev-server": { - "version": "4.9.3", - "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.9.3.tgz", - "integrity": "sha512-3qp/eoboZG5/6QgiZ3llN8TUzkSpYg1Ko9khWX1h40MIEUNS2mDoIa8aXsPfskER+GbTvs/IJZ1QTBBhhuetSw==", + "version": "4.15.1", + "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.15.1.tgz", + "integrity": "sha512-5hbAst3h3C3L8w6W4P96L5vaV0PxSmJhxZvWKYIdgxOQm8pNZ5dEOmmSLBVpP85ReeyRt6AS1QJNyo/oFFPeVA==", "requires": { "@types/bonjour": "^3.5.9", "@types/connect-history-api-fallback": "^1.3.5", @@ -22651,7 +23289,7 @@ "@types/serve-index": "^1.9.1", "@types/serve-static": "^1.13.10", "@types/sockjs": "^0.3.33", - "@types/ws": "^8.5.1", + "@types/ws": "^8.5.5", "ansi-html-community": "^0.0.8", "bonjour-service": "^1.0.11", "chokidar": "^3.5.3", @@ -22664,67 +23302,34 @@ "html-entities": "^2.3.2", "http-proxy-middleware": "^2.0.3", "ipaddr.js": "^2.0.1", + "launch-editor": "^2.6.0", "open": "^8.0.9", "p-retry": "^4.5.0", "rimraf": "^3.0.2", "schema-utils": "^4.0.0", - "selfsigned": "^2.0.1", + "selfsigned": "^2.1.1", "serve-index": "^1.9.1", "sockjs": "^0.3.24", "spdy": "^4.0.2", "webpack-dev-middleware": "^5.3.1", - "ws": "^8.4.2" + "ws": "^8.13.0" }, "dependencies": { - "ajv": { - "version": "8.11.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.11.0.tgz", - "integrity": "sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg==", - "requires": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - } - }, - "ajv-keywords": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", - "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", - "requires": { - "fast-deep-equal": "^3.1.3" - } - }, - "json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==" - }, - "schema-utils": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.0.0.tgz", - "integrity": "sha512-1edyXKgh6XnJsJSQ8mKWXnN/BVaIbFMLpouRUrXgVq7WYne5kw3MW7UPhO44uRXQSIpTSXoJbmrR2X0w9kUTyg==", - "requires": { - "@types/json-schema": "^7.0.9", - "ajv": "^8.8.0", - "ajv-formats": "^2.1.1", - "ajv-keywords": "^5.0.0" - } - }, "ws": { - "version": "8.8.1", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.8.1.tgz", - "integrity": "sha512-bGy2JzvzkPowEJV++hF07hAD6niYSr0JzBNo/J29WsB57A2r7Wlc1UFcTR9IzrPvuNVO4B8LGqF8qcpsVOhJCA==", + "version": "8.14.2", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.14.2.tgz", + "integrity": "sha512-wEBG1ftX4jcglPxgFCMJmZ2PLtSbJ2Peg6TmpJFTbe9GZYOQCDPdMYu/Tm0/bGZkw8paZnJY45J4K2PZrLYq8g==", "requires": {} } } }, "webpack-merge": { - "version": "5.8.0", - "resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.8.0.tgz", - "integrity": "sha512-/SaI7xY0831XwP6kzuwhKWVKDP9t1QY1h65lAFLbZqMPIuYcD9QAW4u9STIbU9kaJbPBB/geU/gLr1wDjOhQ+Q==", + "version": "5.10.0", + "resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.10.0.tgz", + "integrity": "sha512-+4zXKdx7UnO+1jaN4l2lHVD+mFvnlZQP/6ljaJVb4SZiwIKeUnrT5l0gkT8z+n4hKpC+jpOv6O9R+gLtag7pSA==", "requires": { "clone-deep": "^4.0.1", + "flat": "^5.0.2", "wildcard": "^2.0.0" } }, @@ -22790,9 +23395,9 @@ "integrity": "sha512-JcKqAHLPxcdb9KM49dufGXn2x3ssnfjbcaQdLlfZsL9rH9wgDQjUtDxbo8NE0F6SFvydeu1VhZe7hZuHsB2/pw==" }, "wrap-ansi": { - "version": "8.0.1", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.0.1.tgz", - "integrity": "sha512-QFF+ufAqhoYHvoHdajT/Po7KoXVBPXS2bgjIam5isfWJPfIOnQZ50JtUiVvCv/sjgacf3yRrt2ZKUZ/V4itN4g==", + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", "requires": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", diff --git a/doc/docusaurus/src/theme/CodeBlock/hljs_run.js b/doc/docusaurus/src/theme/CodeBlock/hljs_run.js index e4928253c90..27ae9ee0380 100644 --- a/doc/docusaurus/src/theme/CodeBlock/hljs_run.js +++ b/doc/docusaurus/src/theme/CodeBlock/hljs_run.js @@ -78,7 +78,7 @@ export function registerMotoko() { $pattern: "[a-zA-Z_]\\w*", keyword: "actor and await break case catch class" + - " continue debug do else for func if in import" + + " continue composite debug do else for func if in import" + " module not object or label let loop private" + " public return shared try throw query switch" + " type var while with stable flexible system debug_show assert ignore from_candid to_candid", diff --git a/doc/md/actor-classes.md b/doc/md/actor-classes.md deleted file mode 100644 index 8acf74831b0..00000000000 --- a/doc/md/actor-classes.md +++ /dev/null @@ -1,77 +0,0 @@ -# Actor classes - -Actor classes enable you to create networks of actors (canister smart contracts) *programmatically*. Currently, actor classes have to be defined in a separate source file. To illustrate how to define and import actor classes, the following example implements a distributed map of keys of type `Nat` to values of type `Text`. It provides simple insert and lookup functions, `put(k, v)` and `get(k)`, for working with these keys and values. - -To distribute the data for this example, the set of keys is partitioned into `n` buckets. For now, we just fix `n = 8`. The bucket, `i`, of a key, `k`, is determined by the remainder of `k` divided by `n`, that is, `i = k % n`. The `i`th bucket (`i` in `[0..n)`) receives a dedicated actor to store text values assigned to keys in that bucket. - -The actor responsible for bucket `i` is obtained as an instance of the actor class `Bucket(i)`, defined in the sample `Buckets.mo` file, as follows: - -`Buckets.mo`: - -``` motoko name=Buckets file=./examples/Buckets.mo -``` - -A bucket stores the current mapping of keys to values in a mutable `map` variable containing an imperative RedBlack tree, `map`, that is initially empty. - -On `get(k)`, the bucket actor simply returns any value stored at `k`, returning `map.get(k)`. - -On `put(k, v)`, the bucket actor updates the current `map` to map `k` to `?v` by calling `map.put(k, v)`. - -Both functions use the class parameters `n` and `i` to verify that the key is appropriate for the bucket by asserting `((k % n) == i)`. - -Clients of the map can then communicate with a coordinating `Map` actor, implemented as follows: - -``` motoko include=Buckets file=./examples/Map.mo -``` - -As this example illustrates, the `Map` code imports the `Bucket` actor class as module `Buckets`. - -The actor maintains an array of `n` allocated buckets, with all entries initially `null`. Entries are populated with `Bucket` actors on demand. - -On `get(k, v)`, the `Map` actor: - -- uses the remainder of key `k` divided by `n` to determine the index `i` of the bucket responsible for that key - -- returns `null` if the `i`th bucket does not exist, or - -- delegates to that bucket by calling `bucket.get(k, v)` if it does. - -On `put(k, v)`, the `Map` actor: - -- uses the remainder of key `k` divided by `n` to determine the index `i` of the bucket responsible for that key - -- installs bucket `i` if the bucket does not exist by using an asynchronous call to the constructor, `Buckets.Bucket(i)`, and, after awaiting the result, records it in the array `buckets` - -- delegates the insertion to that bucket by calling `bucket.put(k, v)`. - -While this example sets the number of buckets to `8`, you can easily generalize the example by making the `Map` actor an actor *class*, adding a parameter `(n : Nat)` and omitting the declaration `let n = 8;`. For example: - -``` motoko no-repl -actor class Map(n : Nat) { - - type Key = Nat - ... -} -``` - -Clients of actor *class* `Map` are now free to determine the (maximum) number of buckets in the network by passing an argument on construction. - -:::note - - On the Internet Computer, calls to a class constructor must be provisioned with cycles to pay for the creation of a principal. See [ExperimentalCycles](./base/ExperimentalCycles.md) for instructions on how to add cycles to a call using the imperative `ExperimentalCycles.add(cycles)` function. - -::: - -## Configuring and managing actor class instances - -On the Internet Computer, the primary constructor of an imported actor class always creates a new principal and installs a fresh instance of the class as the code for that principal. - -To provide further control over actor class installation, Motoko endows each imported actor class with an extra, secondary constructor. -This constructor takes an additional first argument that specifies the desired installation mode. The constructor is only available via special syntax that stresses its -`system` functionality. - -Using this syntax, it's possible to specify initial canister settings (such as an array of controllers), manually install, upgrade and reinstall canisters, exposing all of the -lower-level facilities of the Internet Computer. - -See [Actor class management](language-manual.md#actor-class-management) for more details. - diff --git a/doc/md/actors-async.md b/doc/md/actors-async.md deleted file mode 100644 index 986f2d17809..00000000000 --- a/doc/md/actors-async.md +++ /dev/null @@ -1,240 +0,0 @@ -# Actors and async data - -The programming model of the Internet Computer consists of memory-isolated canisters communicating by asynchronous message passing of binary data encoding Candid values. A canister processes its messages one-at-a-time, preventing race conditions. A canister uses call-backs to register what needs to be done with the result of any inter-canister messages it issues. - -Motoko abstracts the complexity of the Internet Computer with a well known, higher-level abstraction: the *actor model*. Each canister is represented as a typed actor. The type of an actor lists the messages it can handle. Each message is abstracted as a typed, asynchronous function. A translation from actor types to Candid types imposes structure on the raw binary data of the underlying Internet Computer. An actor is similar to an object, but is different in that its state is completely isolated, its interactions with the world are entirely through asynchronous messaging, and its messages are processed one-at-a-time, even when issued in parallel by concurrent actors. - -In Motoko, sending a message to an actor is a function call, but instead of blocking the caller until the call has returned, the message is enqueued on the callee, and a *future* representing that pending request immediately returned to the caller. The future is a placeholder for the eventual result of the request, that the caller can later query. Between issuing the request, and deciding to wait for the result, the caller is free to do other work, including issuing more requests to the same or other actors. Once the callee has processed the request, the future is completed and its result made available to the caller. If the caller is waiting on the future, its execution can resume with the result, otherwise the result is simply stored in the future for later use. - -In Motoko, actors have dedicated syntax and types; messaging is handled by so called *shared* functions returning futures (shared because they are available to remote actors); a future, `f`, is a value of the special type `async T` for some type `T`; waiting on `f` to be completed is expressed using `await f` to obtain a value of type `T`. To avoid introducing shared state through messaging, for example, by sending an object or mutable array, the data that can be transmitted through shared functions is restricted to immutable, *shared* types. - -To start, we consider the simplest stateful service: a `Counter` actor, the distributed version of our previous, local `counter` object. - -## Example: a Counter service - -Consider the following actor declaration: - -``` motoko file=./examples/counter-actor.mo -``` - - - -The `Counter` actor declares one field and three public, *shared* functions: - -- the field `count` is mutable, initialized to zero and implicitly `private`. - -- function `inc()` asynchronously increments the counter and returns a future of type `async ()` for synchronization. - -- function `read()` asynchronously reads the counter value and returns a future of type `async Nat` containing its value. - -- function `bump()` asynchronously increments and reads the counter. - -Shared functions, unlike local functions, are accessible to remote callers and have additional restrictions: their arguments and return value must be *shared* types - a subset of types that includes immutable data, actor references, and shared function references, but excludes references to local functions and mutable data. Because all interaction with actors is asynchronous, an actor’s functions must return futures, that is, types of the form `async T`, for some type `T`. - -The only way to read or modify the state (`count`) of the `Counter` actor is through its shared functions. - -A value of type `async T` is a future. The producer of the future completes the future when it returns a result, either a value or error. - -Unlike objects and modules, actors can only expose functions, and these functions must be `shared`. For this reason, Motoko allows you to omit the `shared` modifier on public actor functions, allowing the more concise, but equivalent, actor declaration: - -``` motoko name=counter file=./examples/counter-actor-sugar.mo -``` - -For now, the only place shared functions can be declared is in the body of an actor or actor class. Despite this restriction, shared functions are still first-class values in Motoko and can be passed as arguments or results, and stored in data structures. - -The type of a shared function is specified using a shared function type. For example, the value `inc` has type `shared () → async Nat` and could be supplied as a standalone callback to some other service (see [publish-subscribe](sharing.md) for an example). - -## Actor types - -Just as objects have object types, actors have *actor types*. The `Counter` actor has the following type: - -``` motoko no-repl -actor { - inc : shared () -> async (); - read : shared () -> async Nat; - bump : shared () -> async Nat; -} -``` - -Again, because the `shared` modifier is required on every member of an actor, Motoko both elides them on display, and allows you to omit them when authoring an actor type. - -Thus the previous type can be expressed more succinctly as: - -``` motoko no-repl -actor { - inc : () -> async (); - read : () -> async Nat; - bump : () -> async Nat; -} -``` - -Like object types, actor types support subtyping: an actor type is a subtype of a more general one that offers fewer functions with more general types. - -## Using `await` to consume async futures - -The caller of a shared function typically receives a future, a value of type `async T` for some T. - -The only thing the caller, a consumer, can do with this future is wait for it to be completed by the producer, throw it away, or store it for later use. - -To access the result of an `async` value, the receiver of the future use an `await` expression. - -For example, to use the result of `Counter.read()` above, we can first bind the future to an identifier `a`, and then `await a` to retrieve the underlying `Nat`, `n`: - -``` motoko include=counter -let a : async Nat = Counter.read(); -let n : Nat = await a; -``` - -The first line immediately receives *a future of the counter value*, but does not wait for it, and thus cannot (yet) use it as a natural number. - -The second line `await`s this future and extracts the result, a natural number. This line may suspend execution until the future has been completed. - -Typically, one rolls the two steps into one and one just awaits an asynchronous call directly: - -``` motoko include=counter -let n : Nat = await Counter.read(); -``` - -Unlike a local function call, which blocks the caller until the callee has returned a result, a shared function call immediately returns a future, `f`, without blocking. Instead of blocking, a later call to `await f` suspends the current computation until `f` is complete. Once the future is completed (by the producer), execution of `await p` resumes with its result. If the result is a value, `await f` returns that value. Otherwise the result is some error, and `await f` propagates the error to the consumer of `await f`. - -Awaiting a future a second time will just produce the same result, including re-throwing any error stored in the future. Suspension occurs even if the future is already complete; this ensures state changes and message sends prior to *every* `await` are committed. - -:::danger - -A function that does not `await` in its body is guaranteed to execute atomically - in particular, the environment cannot change the state of the actor while the function is executing. If a function performs an `await`, however, atomicity is no longer guaranteed. Between suspension and resumption around the `await`, the state of the enclosing actor may change due to concurrent processing of other incoming actor messages. It is the programmer’s responsibility to guard against non-synchronized state changes. A programmer may, however, rely on any state change prior to the await being committed. - -::: - -For example, the implementation of `bump()` above is guaranteed to increment and read the value of `count`, in one atomic step. The alternative implementation: - -``` motoko no-repl - public shared func bump() : async Nat { - await inc(); - await read(); - }; -``` - -does *not* have the same semantics and allows another client of the actor to interfere with its operation: each `await` suspends execution, allowing an interloper to change the state of the actor. By design, the explicit `await`s make the potential points of interference clear to the reader. - -## Traps and Commit Points - -A trap is a non-recoverable runtime failure caused by, for example, division-by-zero, out-of-bounds array indexing, numeric overflow, cycle exhaustion or assertion failure. - -A shared function call that executes without executing an `await` expression never suspends and executes atomically. A shared function that contains no `await` expression is syntactically atomic. - -An atomic shared function whose execution traps has no visible effect on the state of the enclosing actor or its environment - any state change is reverted, and any message that it has sent is revoked. In fact, all state changes and message sends are tentative during execution: they are committed only after a successful *commit point* is reached. - -The points at which tentative state changes and message sends are irrevocably committed are: - -- implicit exit from a shared function by producing a result, - -- explict exit via `return` or `throw` expressions, and - -- explicit `await` expressions. - -A trap will only revoke changes made since the last commit point. In particular, in a non-atomic function that does multiple awaits, a trap will only revoke changes attempted since the last await - all preceding effects will have been committed and cannot be undone. - -For example, consider the following (contrived) stateful `Atomicity` actor: - -``` motoko no-repl file=./examples/atomicity.mo -``` - -Calling (shared) function `atomic()` will fail with an error, since the last statement causes a trap. However, the trap leaves the mutable variable `s` with value `0`, not `1`, and variable `pinged` with value `false`, not `true`. This is because the trap happens *before* method `atomic` has executed an `await`, or exited with a result. Even though `atomic` calls `ping()`, `ping()` is tentative (queued) until the next commit point, so never delivered. - -Calling (shared) function `nonAtomic()` will fail with an error, since the last statement causes a trap. However, the trap leaves the variable `s` with value `3`, not `0`, and variable `pinged` with value `true`, not `false`. This is because each `await` commits its preceding side-effects, including message sends. Even though `f` is complete by the second await on `f`, this await also forces a commit of the state, suspends execution and allows for interleaved processing of other messages to this actor. - -## Query functions - -In Internet Computer terminology, all three `Counter` functions are *update* messages that can alter the state of the canister when called. Effecting a state change requires agreement amongst the distributed replicas before the Internet Computer can commit the change and return a result. Reaching consensus is an expensive process with relatively high latency. - -For the parts of applications that don’t require the guarantees of consensus, the Internet Computer supports more efficient *query* operations. These are able to read the state of a canister from a single replica, modify a snapshot during their execution and return a result, but cannot permanently alter the state or send further Internet Computer messages. - -Motoko supports the implementation of Internet Computer queries using `query` functions. The `query` keyword modifies the declaration of a (shared) actor function so that it executes with non-committing, and faster, Internet Computer query semantics. - -For example, we can extend the `Counter` actor with a fast-and-loose variant of the trustworthy `read` function, called `peek`: - -``` motoko file=./examples/CounterWithQuery.mo -``` - -The `peek()` function might be used by a `Counter` frontend offering a quick, but less trustworthy, display of the current counter value. - -It is a compile-time error for a query method to call an actor function since this would violate dynamic restrictions imposed by the Internet Computer. Calls to ordinary functions are permitted. - -Query functions can be called from non-query functions. Because those nested calls require consensus, the efficiency gains of nested query calls will be modest at best. - -The `query` modifier is reflected in the type of a query function: - -``` motoko no-repl - peek : shared query () -> async Nat -``` - -As before, in `query` declarations and actor types the `shared` keyword can be omitted. - -## Messaging Restrictions - -The Internet Computer places restrictions on when and how canisters are allowed to communicate. These restrictions are enforced dynamically on the Internet Computer but prevented statically in Motoko, ruling out a class of dynamic execution errors. Two examples are: - -- canister installation can execute code, but not send messages. - -- a canister query method cannot send messages. - -These restrictions are surfaced in Motoko as restrictions on the context in which certain expressions can be used. - -In Motoko, an expression occurs in an *asynchronous context* if it appears in the body of an `async` expression, which may be the body of a (shared or local) function or a stand-alone expression. The only exception are `query` functions, whose body is not considered to open an asynchronous context. - -In Motoko calling a shared function is an error unless the function is called in an asynchronouus context. In addition, calling a shared function from an actor class constructor is also an error. - -The `await` construct is only allowed in an asynchronous context. - -The `async` construct is only allowed in an asynchronous context. - -It is only possible to `throw` or `try/catch` errors in an asynchronous context. This is because structured error handling is supported for messaging errors only and, like messaging itself, confined to asynchronous contexts. - -These rules also mean that local functions cannot, in general, directly call shared functions or `await` futures. This limitation can sometimes be awkward: we hope to extend the type system to be more permissive in future. - - - -## Actor classes generalize actors - -An actor *class* generalizes a single actor declaration to the declaration of family of actors satisfying the same interface. An actor class declares a type, naming the interface of its actors, and a function that constructs a fresh actor of that type each time it is supplied with an argument. An actor class thus serves as a factory for manufacturing actors. Because canister installation is asynchronous on the Internet Computer, the constructor function is asynchronous too, and returns its actor in a future. - -For example, we can generalize `Counter` given above to `Counter(init)` below, by introducing a constructor parameter, variable `init` of type `Nat`: - -`Counters.mo`: - -``` motoko name=Counters file=./examples/Counters.mo -``` - -If this class is stored in file `Counters.mo`, then we can import the file as a module and use it to create several actors with different initial values: - -``` motoko include=Counters -import Counters "Counters"; - -let C1 = await Counters.Counter(1); -let C2 = await Counters.Counter(2); -(await C1.read(), await C2.read()) -``` - -The last two lines above *instantiate* the actor class twice. The first invocation uses the initial value `1`, where the second uses initial value `2`. Because actor class instantiation is asynchronous, each call to `Counter(init)` returns a future that can be `await`ed for the resulting actor value. Both `C1` and `C2` have the same type, `Counters.Counter` and can be used interchangeably. - -:::note - -For now, the Motoko compiler gives an error when compiling programs that do not consist of a single actor or actor class. Compiled programs may still, however, reference imported actor classes. For more information, see [Importing actor classes](modules-and-imports.md#importing-actor-classes) and [Actor classes](actor-classes.md#actor-classes). - -::: diff --git a/doc/md/base-intro.md b/doc/md/base-intro.md deleted file mode 100644 index 563416fc184..00000000000 --- a/doc/md/base-intro.md +++ /dev/null @@ -1,24 +0,0 @@ -# Using Motoko base modules - -The design of Motoko strives to minimize built-in types and operations. Instead of built-in types, Motoko provides a base library of modules to handle many kinds of common operations and make the language feel complete. This base library is still evolving with modules that support core features and all of the base library APIs are subject to change over time to varying degrees. You should note, in particular, that the size and number of modules and functions included in the base library is likely to increase dramatically and updates to the base library modules might introduce breaking changes that require you to update your programs to remain compatible. - -## Importing from the base library - -To import from the base library, use the `import` keyword followed by a local module name and a URL where the `import` declaration can find the module you want to import. For example: - -``` motoko -import Debug "mo:base/Debug"; -Debug.print("hello world"); -``` - -This example illustrates how to import Motoko code—indicated by using the `mo:` prefix—using the `base/` base library path and the module name `Debug`. You can also import Motoko code and other modules using relative paths. For example, if you have created a Motoko program named `types.mo` in the same folder as your main program, you could include it with an import declaration like this: - -``` motoko no-repl -import Types "./types"; -``` - -## Viewing the base library modules - -You can find source code and documentation for Motoko base modules in the [motoko-base](https://github.com/dfinity/motoko-base) open source repository. There are instructions in the repository for generating a local copy of the current documentation for the Motoko base library. - -You can also search for documentation by using Search in any page of the Developer Center. diff --git a/doc/md/base/Array.md b/doc/md/base/Array.md index 7b9e1762745..8240932c8fc 100644 --- a/doc/md/base/Array.md +++ b/doc/md/base/Array.md @@ -146,7 +146,7 @@ func append(array1 : [X], array2 : [X]) : [X] ``` Create a new array by appending the values of `array1` and `array2`. -@deprecated `Array.append` copies its arguments and has linear complexity; +Note that `Array.append` copies its arguments and has linear complexity; when used in a loop, consider using a `Buffer`, and `Buffer.append`, instead. ```motoko include=import @@ -503,7 +503,7 @@ Space: O(1) ## Function `subArray` ``` motoko no-repl -func subArray(arr : [X], start : Nat, length : Nat) : [X] +func subArray(array : [X], start : Nat, length : Nat) : [X] ``` Returns a new subarray from the given array provided the start index and length of elements in the subarray @@ -514,5 +514,122 @@ Limitations: Traps if the start index + length is greater than the size of the a let array = [1,2,3,4,5]; let subArray = Array.subArray(array, 2, 3); +``` +Runtime: O(length); +Space: O(length); + +## Function `indexOf` +``` motoko no-repl +func indexOf(element : X, array : [X], equal : (X, X) -> Bool) : ?Nat +``` + +Returns the index of the first `element` in the `array`. + +```motoko include=import +import Char "mo:base/Char"; +let array = ['c', 'o', 'f', 'f', 'e', 'e']; +assert Array.indexOf('c', array, Char.equal) == ?0; +assert Array.indexOf('f', array, Char.equal) == ?2; +assert Array.indexOf('g', array, Char.equal) == null; +``` + +Runtime: O(array.size()); +Space: O(1); + +## Function `nextIndexOf` +``` motoko no-repl +func nextIndexOf(element : X, array : [X], fromInclusive : Nat, equal : (X, X) -> Bool) : ?Nat +``` + +Returns the index of the next occurence of `element` in the `array` starting from the `from` index (inclusive). + +```motoko include=import +import Char "mo:base/Char"; +let array = ['c', 'o', 'f', 'f', 'e', 'e']; +assert Array.nextIndexOf('c', array, 0, Char.equal) == ?0; +assert Array.nextIndexOf('f', array, 0, Char.equal) == ?2; +assert Array.nextIndexOf('f', array, 2, Char.equal) == ?2; +assert Array.nextIndexOf('f', array, 3, Char.equal) == ?3; +assert Array.nextIndexOf('f', array, 4, Char.equal) == null; +``` + +Runtime: O(array.size()); +Space: O(1); + +## Function `lastIndexOf` +``` motoko no-repl +func lastIndexOf(element : X, array : [X], equal : (X, X) -> Bool) : ?Nat +``` + +Returns the index of the last `element` in the `array`. + +```motoko include=import +import Char "mo:base/Char"; +let array = ['c', 'o', 'f', 'f', 'e', 'e']; +assert Array.lastIndexOf('c', array, Char.equal) == ?0; +assert Array.lastIndexOf('f', array, Char.equal) == ?3; +assert Array.lastIndexOf('e', array, Char.equal) == ?5; +assert Array.lastIndexOf('g', array, Char.equal) == null; +``` + +Runtime: O(array.size()); +Space: O(1); + +## Function `prevIndexOf` +``` motoko no-repl +func prevIndexOf(element : T, array : [T], fromExclusive : Nat, equal : (T, T) -> Bool) : ?Nat +``` + +Returns the index of the previous occurance of `element` in the `array` starting from the `from` index (exclusive). + +```motoko include=import +import Char "mo:base/Char"; +let array = ['c', 'o', 'f', 'f', 'e', 'e']; +assert Array.prevIndexOf('c', array, array.size(), Char.equal) == ?0; +assert Array.prevIndexOf('e', array, array.size(), Char.equal) == ?5; +assert Array.prevIndexOf('e', array, 5, Char.equal) == ?4; +assert Array.prevIndexOf('e', array, 4, Char.equal) == null; +``` + +Runtime: O(array.size()); +Space: O(1); + +## Function `slice` +``` motoko no-repl +func slice(array : [X], fromInclusive : Nat, toExclusive : Nat) : I.Iter +``` + +Returns an iterator over a slice of the given array. + +```motoko include=import +let array = [1, 2, 3, 4, 5]; +let s = Array.slice(array, 3, array.size()); +assert s.next() == ?4; +assert s.next() == ?5; +assert s.next() == null; + +let s = Array.slice(array, 0, 0); +assert s.next() == null; +``` + +Runtime: O(1) +Space: O(1) + +## Function `take` +``` motoko no-repl +func take(array : [T], length : Int) : [T] +``` + +Returns a new subarray of given length from the beginning or end of the given array + +Returns the entire array if the length is greater than the size of the array + +```motoko include=import +let array = [1, 2, 3, 4, 5]; +assert Array.take(array, 2) == [1, 2]; +assert Array.take(array, -2) == [4, 5]; +assert Array.take(array, 10) == [1, 2, 3, 4, 5]; +assert Array.take(array, -99) == [1, 2, 3, 4, 5]; +``` Runtime: O(length); Space: O(length); diff --git a/doc/md/base/Blob.md b/doc/md/base/Blob.md index 6c60ddc91f6..883c072f0ac 100644 --- a/doc/md/base/Blob.md +++ b/doc/md/base/Blob.md @@ -18,7 +18,7 @@ Some built in features not listed in this module: * `b.size() : Nat` returns the number of bytes in the blob `b`; * `b.vals() : Iter.Iter` returns an iterator to enumerate the bytes of the blob `b`. - For example: +For example: ```motoko include=import import Debug "mo:base/Debug"; import Nat8 "mo:base/Nat8"; @@ -104,7 +104,7 @@ Blob.hash(blob) // => 1_818_567_776 ## Function `compare` ``` motoko no-repl -func compare(blob1 : Blob, blob2 : Blob) : {#less; #equal; #greater} +func compare(b1 : Blob, b2 : Blob) : {#less; #equal; #greater} ``` General purpose comparison function for `Blob` by comparing the value of diff --git a/doc/md/base/ExperimentalCycles.md b/doc/md/base/ExperimentalCycles.md index 270b6844c90..5b22fb6adb8 100644 --- a/doc/md/base/ExperimentalCycles.md +++ b/doc/md/base/ExperimentalCycles.md @@ -18,7 +18,7 @@ import Debug "mo:base/Debug"; actor { public func main() : async() { Debug.print("Main balance: " # debug_show(Cycles.balance())); - Cycles.add(15_000_000); + Cycles.add(15_000_000); await operation(); // accepts 10_000_000 cycles Debug.print("Main refunded: " # debug_show(Cycles.refunded())); // 5_000_000 Debug.print("Main balance: " # debug_show(Cycles.balance())); // decreased by around 10_000_000 @@ -27,7 +27,7 @@ actor { func operation() : async() { Debug.print("Operation balance: " # debug_show(Cycles.balance())); Debug.print("Operation available: " # debug_show(Cycles.available())); - let obtained = Cycles.accept(10_000_000); + let obtained = Cycles.accept(10_000_000); Debug.print("Operation obtained: " # debug_show(obtained)); // => 10_000_000 Debug.print("Operation balance: " # debug_show(Cycles.balance())); // increased by 10_000_000 Debug.print("Operation available: " # debug_show(Cycles.available())); // decreased by 10_000_000 @@ -95,12 +95,12 @@ import Debug "mo:base/Debug"; actor { public func main() : async() { - Cycles.add(15_000_000); + Cycles.add(15_000_000); await operation(); // accepts 10_000_000 cycles }; func operation() : async() { - let obtained = Cycles.accept(10_000_000); + let obtained = Cycles.accept(10_000_000); Debug.print("Obtained: " # debug_show(obtained)); // => 10_000_000 } } @@ -128,11 +128,11 @@ import Cycles "mo:base/ExperimentalCycles"; actor { func operation() : async() { - ignore Cycles.accept(10_000_000); + ignore Cycles.accept(10_000_000); }; public func main() : async() { - Cycles.add(15_000_000); + Cycles.add(15_000_000); await operation(); } } @@ -156,11 +156,11 @@ import Debug "mo:base/Debug"; actor { func operation() : async() { - ignore Cycles.accept(10_000_000); + ignore Cycles.accept(10_000_000); }; public func main() : async() { - Cycles.add(15_000_000); + Cycles.add(15_000_000); await operation(); // accepts 10_000_000 cycles Debug.print("Refunded: " # debug_show(Cycles.refunded())); // 5_000_000 } diff --git a/doc/md/base/ExperimentalInternetComputer.md b/doc/md/base/ExperimentalInternetComputer.md index 4d0a7aa13ad..1a5f511d7bf 100644 --- a/doc/md/base/ExperimentalInternetComputer.md +++ b/doc/md/base/ExperimentalInternetComputer.md @@ -30,7 +30,7 @@ let rawReply = await IC.call(ledger, method, to_candid(input)); // serialized Ca let output : ?OutputType = from_candid(rawReply); // { decimals = 8 } ``` -[Learn more about Candid serialization](https://internetcomputer.org/docs/current/developer-docs/build/cdks/motoko-dfinity/language-manual#candid-serialization) +[Learn more about Candid serialization](https://internetcomputer.org/docs/current/motoko/main/reference/language-manual#candid-serialization) ## Function `countInstructions` ``` motoko no-repl @@ -53,3 +53,32 @@ let count = IC.countInstructions(func() { // ... }); ``` + +## Value `performanceCounter` +``` motoko no-repl +let performanceCounter : (counter : Nat32) -> (value : Nat64) +``` + +Returns the current value of IC _performance counter_ `counter`. + +* Counter `0` is the _current execution instruction counter_, counting instructions only since the beginning of the current IC message. + This counter is reset to value `0` on shared function entry and every `await`. + It is therefore only suitable for measuring the cost of synchronous code. + +* Counter `1` is the _call context instruction counter_ for the current shared function call. + For replicated message executing, this excludes the cost of nested IC calls (even to the current canister). + For non-replicated messages, such as composite queries, it includes the cost of nested calls. + The current value of this counter is preserved across `awaits` (unlike counter `0`). + +* The function (currently) traps if `counter` >= 2. + +Consult [Performance Counter](https://internetcomputer.org/docs/current/references/ic-interface-spec#system-api-performance-counter) for details. + +Example: +```motoko no-repl +import IC "mo:base/ExperimentalInternetComputer"; + +let c1 = IC.performanceCounter(1); +work(); +let diff : Nat64 = IC.performanceCounter(1) - c1; +``` diff --git a/doc/md/base/ExperimentalStableMemory.md b/doc/md/base/ExperimentalStableMemory.md index ca86d7e00eb..eee62ef66bf 100644 --- a/doc/md/base/ExperimentalStableMemory.md +++ b/doc/md/base/ExperimentalStableMemory.md @@ -5,6 +5,11 @@ Byte-level access to (virtual) _stable memory_. and may be replaced by safer alternatives in later versions of Motoko. Use at your own risk and discretion. +**DEPRECATION**: Use of `ExperimentalStableMemory` library may be deprecated in future. +Going forward, users should consider using library `Region.mo` to allocate *isolated* regions of memory instead. +Using dedicated regions for different user applications ensures that writing +to one region will not affect the state of another, unrelated region. + This is a lightweight abstraction over IC _stable memory_ and supports persisting raw binary data across Motoko upgrades. Use of this module is fully compatible with Motoko's use of @@ -30,7 +35,7 @@ NB: The IC's actual stable memory size (`ic0.stable_size`) may exceed the page size reported by Motoko function `size()`. This (and the cap on growth) are to accommodate Motoko's stable variables. Applications that plan to use Motoko stable variables sparingly or not at all can -increase `--max-stable-pages` as desired, approaching the IC maximum (initially 8GiB, then 32Gib, currently 48Gib). +increase `--max-stable-pages` as desired, approaching the IC maximum (initially 8GiB, then 32Gib, currently 64Gib). All applications should reserve at least one page for stable variable data, even when no stable variables are used. Usage: diff --git a/doc/md/base/Float.md b/doc/md/base/Float.md index 06b19128493..c7e02ca529b 100644 --- a/doc/md/base/Float.md +++ b/doc/md/base/Float.md @@ -39,6 +39,9 @@ Advice: * For absolute precision, it is recommened to encode the fraction number as a pair of a Nat for the base and a Nat for the exponent (decimal point). +NaN sign: +* The NaN sign is only applied by `abs`, `neg`, and `copySign`. Other operations can have an arbitrary + sign bit for NaN results. ## Type `Float` ``` motoko no-repl @@ -72,7 +75,7 @@ Determines whether the `number` is a `NaN` ("not a number" in the floating point Notes: * Equality test of `NaN` with itself or another number is always `false`. * There exist many internal `NaN` value representations, such as positive and negative NaN, - signalling and quiet nans, each with many different bit representations. + signalling and quiet NaNs, each with many different bit representations. Example: ```motoko @@ -92,7 +95,7 @@ Special cases: ``` abs(+inf) => +inf abs(-inf) => +inf -abs(NaN) => NaN +abs(-NaN) => +NaN abs(-0.0) => 0.0 ``` @@ -177,7 +180,7 @@ let trunc : (x : Float) -> Float ``` Returns the nearest integral float not greater in magnitude than `x`. -This is equilvent to returning `x` with truncating its decimal places. +This is equivalent to returning `x` with truncating its decimal places. Special cases: ``` @@ -477,7 +480,7 @@ Float.log(Float.e) // => 1.0 ## Function `format` ``` motoko no-repl -func format(fmt : {#fix : Nat8; #exp : Nat8; #gen : Nat8; #hex : Nat8; #exact}, x : Float) : Text +func format(fmt : {#fix : Nat8; #exp : Nat8; #gen : Nat8; #exact}, x : Float) : Text ``` Formatting. `format(fmt, x)` formats `x` to `Text` according to the @@ -486,13 +489,15 @@ formatting directive `fmt`, which can take one of the following forms: * `#fix prec` as fixed-point format with `prec` digits * `#exp prec` as exponential format with `prec` digits * `#gen prec` as generic format with `prec` digits -* `#hex prec` as hexadecimal format with `prec` digits * `#exact` as exact format that can be decoded without loss. `-0.0` is formatted with negative sign bit. -Positive infinity is formatted as `inf`. -Negative infinity is formatted as `-inf`. -`NaN` is formatted as `NaN` or `-NaN` depending on its sign bit. +Positive infinity is formatted as "inf". +Negative infinity is formatted as "-inf". + +Note: The numerical precision and the text format can vary between +Motoko versions and runtime configuration. Moreover, `NaN` can be printed +differently, i.e. "NaN" or "nan", potentially omitting the `NaN` sign. Example: ```motoko @@ -616,12 +621,12 @@ Traps if `epsilon` is negative or `NaN`. Special cases: ``` -equal(+0.0, -0.0, epsilon) => true for any `epsilon >= 0.0` -equal(-0.0, +0.0, epsilon) => true for any `epsilon >= 0.0` -equal(+inf, +inf, epsilon) => true for any `epsilon >= 0.0` -equal(-inf, -inf, epsilon) => true for any `epsilon >= 0.0` -equal(x, NaN, epsilon) => false for any x and `epsilon >= 0.0` -equal(NaN, y, epsilon) => false for any y and `epsilon >= 0.0` +equalWithin(+0.0, -0.0, epsilon) => true for any `epsilon >= 0.0` +equalWithin(-0.0, +0.0, epsilon) => true for any `epsilon >= 0.0` +equalWithin(+inf, +inf, epsilon) => true for any `epsilon >= 0.0` +equalWithin(-inf, -inf, epsilon) => true for any `epsilon >= 0.0` +equalWithin(x, NaN, epsilon) => false for any x and `epsilon >= 0.0` +equalWithin(NaN, y, epsilon) => false for any y and `epsilon >= 0.0` ``` Example: @@ -629,7 +634,7 @@ Example: import Float "mo:base/Float"; let epsilon = 1e-6; -Float.equal(-12.3, -1.23e1, epsilon) // => true +Float.equalWithin(-12.3, -1.23e1, epsilon) // => true ``` ## Function `notEqualWithin` @@ -645,12 +650,12 @@ Traps if `epsilon` is negative or `NaN`. Special cases: ``` -notEqual(+0.0, -0.0, epsilon) => false for any `epsilon >= 0.0` -notEqual(-0.0, +0.0, epsilon) => false for any `epsilon >= 0.0` -notEqual(+inf, +inf, epsilon) => false for any `epsilon >= 0.0` -notEqual(-inf, -inf, epsilon) => false for any `epsilon >= 0.0` -notEqual(x, NaN, epsilon) => true for any x and `epsilon >= 0.0` -notEqual(NaN, y, epsilon) => true for any y and `epsilon >= 0.0` +notEqualWithin(+0.0, -0.0, epsilon) => false for any `epsilon >= 0.0` +notEqualWithin(-0.0, +0.0, epsilon) => false for any `epsilon >= 0.0` +notEqualWithin(+inf, +inf, epsilon) => false for any `epsilon >= 0.0` +notEqualWithin(-inf, -inf, epsilon) => false for any `epsilon >= 0.0` +notEqualWithin(x, NaN, epsilon) => true for any x and `epsilon >= 0.0` +notEqualWithin(NaN, y, epsilon) => true for any y and `epsilon >= 0.0` ``` Example: @@ -658,7 +663,7 @@ Example: import Float "mo:base/Float"; let epsilon = 1e-6; -Float.notEqual(-12.3, -1.23e1, epsilon) // => false +Float.notEqualWithin(-12.3, -1.23e1, epsilon) // => false ``` ## Function `less` @@ -757,8 +762,8 @@ func compare(x : Float, y : Float) : {#less; #equal; #greater} Defines a total order of `x` and `y` for use in sorting. Note: Using this operation to determine equality or inequality is discouraged for two reasons: -* It does not consider numerical errors, see comment above. Use `equal(x, y)` or - `notEqual(x, y)` to test for equality or inequality, respectively. +* It does not consider numerical errors, see comment above. Use `equalWithin(x, y, espilon)` or + `notEqualWithin(x, y, epsilon)` to test for equality or inequality, respectively. * `NaN` are here considered equal if their sign matches, which is different to the standard equality by `==` or when using `equal()` or `notEqual()`. @@ -787,8 +792,16 @@ func neg(x : Float) : Float Returns the negation of `x`, `-x` . Changes the sign bit for infinity. -Issue: Inconsistent behavior for zero and `NaN`. Probably related to -https://github.com/dfinity/motoko/issues/3646 + +Special cases: +``` +neg(+inf) => -inf +neg(-inf) => +inf +neg(+NaN) => -NaN +neg(-NaN) => +NaN +neg(+0.0) => -0.0 +neg(-0.0) => +0.0 +``` Example: ```motoko diff --git a/doc/md/base/Int.md b/doc/md/base/Int.md index f731a0172eb..80e784f8e84 100644 --- a/doc/md/base/Int.md +++ b/doc/md/base/Int.md @@ -233,6 +233,11 @@ Example: Int.neg(123) // => -123 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. + ## Function `add` ``` motoko no-repl func add(x : Int, y : Int) : Int diff --git a/doc/md/base/Int16.md b/doc/md/base/Int16.md index 9e5ec937a76..4ec85bb969f 100644 --- a/doc/md/base/Int16.md +++ b/doc/md/base/Int16.md @@ -1,8 +1,12 @@ # Int16 -16-bit signed integers with checked arithmetic. +Provides utility functions on 16-bit signed integers. -Common 16-bit integer functions. -Most operations are available as built-in operators (e.g. `1 + 1`). +Note that most operations are available as built-in operators (e.g. `1 + 1`). + +Import from the base library to use this module. +```motoko name=import +import Int16 "mo:base/Int16"; +``` ## Type `Int16` ``` motoko no-repl @@ -18,6 +22,11 @@ let minimumValue : Int16 Minimum 16-bit integer value, `-2 ** 15`. +Example: +```motoko include=import +Int16.minimumValue // => -32_768 : Int16 +``` + ## Value `maximumValue` ``` motoko no-repl let maximumValue : Int16 @@ -25,6 +34,11 @@ let maximumValue : Int16 Maximum 16-bit integer value, `+2 ** 15 - 1`. +Example: +```motoko include=import +Int16.maximumValue // => +32_767 : Int16 +``` + ## Value `toInt` ``` motoko no-repl let toInt : Int16 -> Int @@ -33,9 +47,7 @@ let toInt : Int16 -> Int Converts a 16-bit signed integer to a signed integer with infinite precision. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.toInt(12_345) // => 12_345 : Int ``` @@ -49,9 +61,7 @@ Converts a signed integer with infinite precision to a 16-bit signed integer. Traps on overflow/underflow. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.fromInt(12_345) // => +12_345 : Int16 ``` @@ -65,12 +75,62 @@ Converts a signed integer with infinite precision to a 16-bit signed integer. Wraps on overflow/underflow. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.fromIntWrap(-12_345) // => -12_345 : Int ``` +## Value `fromInt8` +``` motoko no-repl +let fromInt8 : Int8 -> Int16 +``` + +Converts a 8-bit signed integer to a 16-bit signed integer. + +Example: +```motoko include=import +Int16.fromInt8(-123) // => -123 : Int16 +``` + +## Value `toInt8` +``` motoko no-repl +let toInt8 : Int16 -> Int8 +``` + +Converts a 16-bit signed integer to a 8-bit signed integer. + +Traps on overflow/underflow. + +Example: +```motoko include=import +Int16.toInt8(-123) // => -123 : Int8 +``` + +## Value `fromInt32` +``` motoko no-repl +let fromInt32 : Int32 -> Int16 +``` + +Converts a 32-bit signed integer to a 16-bit signed integer. + +Traps on overflow/underflow. + +Example: +```motoko include=import +Int16.fromInt32(-12_345) // => -12_345 : Int16 +``` + +## Value `toInt32` +``` motoko no-repl +let toInt32 : Int16 -> Int32 +``` + +Converts a 16-bit signed integer to a 32-bit signed integer. + +Example: +```motoko include=import +Int16.toInt32(-12_345) // => -12_345 : Int32 +``` + ## Value `fromNat16` ``` motoko no-repl let fromNat16 : Nat16 -> Int16 @@ -81,9 +141,7 @@ Converts an unsigned 16-bit integer to a signed 16-bit integer. Wraps on overflow/underflow. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.fromNat16(12_345) // => +12_345 : Int16 ``` @@ -97,9 +155,7 @@ Converts a signed 16-bit integer to an unsigned 16-bit integer. Wraps on overflow/underflow. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.toNat16(-1) // => 65_535 : Nat16 // underflow ``` @@ -108,13 +164,11 @@ Int16.toNat16(-1) // => 65_535 : Nat16 // underflow func toText(x : Int16) : Text ``` -Returns the Text representation of `x`. -Formats the integer in decimal representation without underscore separators for thousand figures. +Returns the Text representation of `x`. Textual representation _do not_ +contain underscores to represent commas. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.toText(-12345) // => "-12345" ``` @@ -128,9 +182,7 @@ Returns the absolute value of `x`. Traps when `x == -2 ** 15` (the minimum `Int16` value). Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.abs(-12345) // => +12_345 ``` @@ -142,9 +194,7 @@ func min(x : Int16, y : Int16) : Int16 Returns the minimum of `x` and `y`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.min(+2, -3) // => -3 ``` @@ -156,9 +206,7 @@ func max(x : Int16, y : Int16) : Int16 Returns the maximum of `x` and `y`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.max(+2, -3) // => +2 ``` @@ -167,13 +215,28 @@ Int16.max(+2, -3) // => +2 func equal(x : Int16, y : Int16) : Bool ``` -Returns `x == y`. +Equality function for Int16 types. +This is equivalent to `x == y`. Example: -```motoko -import Int16 "mo:base/Int16"; +```motoko include=import +Int16.equal(-1, -1); // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `==` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `==` +as a function value at the moment. -Int16.equal(123, 123) // => true +Example: +```motoko include=import +import Buffer "mo:base/Buffer"; + +let buffer1 = Buffer.Buffer(1); +buffer1.add(-3); +let buffer2 = Buffer.Buffer(1); +buffer2.add(-3); +Buffer.equal(buffer1, buffer2, Int16.equal) // => true ``` ## Function `notEqual` @@ -181,55 +244,66 @@ Int16.equal(123, 123) // => true func notEqual(x : Int16, y : Int16) : Bool ``` -Returns `x != y`. +Inequality function for Int16 types. +This is equivalent to `x != y`. Example: -```motoko -import Int16 "mo:base/Int16"; - -Int16.notEqual(123, 123) // => false +```motoko include=import +Int16.notEqual(-1, -2); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `!=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `!=` +as a function value at the moment. + ## Function `less` ``` motoko no-repl func less(x : Int16, y : Int16) : Bool ``` -Returns `x < y`. +"Less than" function for Int16 types. +This is equivalent to `x < y`. Example: -```motoko -import Int16 "mo:base/Int16"; - -Int16.less(123, 1234) // => true +```motoko include=import +Int16.less(-2, 1); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<` +as a function value at the moment. + ## Function `lessOrEqual` ``` motoko no-repl func lessOrEqual(x : Int16, y : Int16) : Bool ``` -Returns `x <= y`. +"Less than or equal" function for Int16 types. +This is equivalent to `x <= y`. Example: -```motoko -import Int16 "mo:base/Int16"; - -Int16.lessOrEqual(123, 1234) // => true +```motoko include=import +Int16.lessOrEqual(-2, -2); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<=` +as a function value at the moment. + ## Function `greater` ``` motoko no-repl func greater(x : Int16, y : Int16) : Bool ``` -Returns `x > y`. +"Greater than" function for Int16 types. +This is equivalent to `x > y`. Example: -```motoko -import Int16 "mo:base/Int16"; - -Int16.greater(1234, 123) // => true +```motoko include=import +Int16.greater(-2, 1); // => false ``` ## Function `greaterOrEqual` @@ -237,13 +311,12 @@ Int16.greater(1234, 123) // => true func greaterOrEqual(x : Int16, y : Int16) : Bool ``` -Returns `x >= y`. +"Greater than or equal" function for Int16 types. +This is equivalent to `x >= y`. Example: -```motoko -import Int16 "mo:base/Int16"; - -Int16.greaterOrEqual(1234, 123) // => true +```motoko include=import +Int16.greaterOrEqual(-2, -2); // => true ``` ## Function `compare` @@ -251,13 +324,20 @@ Int16.greaterOrEqual(1234, 123) // => true func compare(x : Int16, y : Int16) : {#less; #equal; #greater} ``` -Returns the order of `x` and `y`. +General-purpose comparison function for `Int16`. Returns the `Order` ( +either `#less`, `#equal`, or `#greater`) of comparing `x` with `y`. Example: -```motoko -import Int16 "mo:base/Int16"; +```motoko include=import +Int16.compare(-3, 2) // => #less +``` -Int16.compare(123, 1234) // => #less +This function can be used as value for a high order function, such as a sort function. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.sort([1, -2, -3] : [Int16], Int16.compare) // => [-3, -2, 1] ``` ## Function `neg` @@ -269,14 +349,16 @@ Returns the negation of `x`, `-x`. Traps on overflow, i.e. for `neg(-2 ** 15)`. - Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.neg(123) // => -123 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. + ## Function `add` ``` motoko no-repl func add(x : Int16, y : Int16) : Int16 @@ -287,10 +369,19 @@ Returns the sum of `x` and `y`, `x + y`. Traps on overflow/underflow. Example: -```motoko -import Int16 "mo:base/Int16"; +```motoko include=import +Int16.add(100, 23) // => +123 +``` -Int16.add(1234, 123) // => +1_357 +Note: The reason why this function is defined in this library (in addition +to the existing `+` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 0, Int16.add) // => -4 ``` ## Function `sub` @@ -303,10 +394,19 @@ Returns the difference of `x` and `y`, `x - y`. Traps on overflow/underflow. Example: -```motoko -import Int16 "mo:base/Int16"; +```motoko include=import +Int16.sub(123, 100) // => +23 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. -Int16.sub(1234, 123) // => +1_111 +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 0, Int16.sub) // => 4 ``` ## Function `mul` @@ -319,10 +419,19 @@ Returns the product of `x` and `y`, `x * y`. Traps on overflow/underflow. Example: -```motoko -import Int16 "mo:base/Int16"; +```motoko include=import +Int16.mul(12, 10) // => +120 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `*` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*` +as a function value at the moment. -Int16.mul(123, 100) // => +12_300 +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 1, Int16.mul) // => 6 ``` ## Function `div` @@ -336,12 +445,15 @@ Rounds the quotient towards zero, which is the same as truncating the decimal pl Traps when `y` is zero. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.div(123, 10) // => +12 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `/` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `/` +as a function value at the moment. + ## Function `rem` ``` motoko no-repl func rem(x : Int16, y : Int16) : Int16 @@ -353,12 +465,15 @@ which is defined as `x - x / y * y`. Traps when `y` is zero. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.rem(123, 10) // => +3 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `%` +as a function value at the moment. + ## Function `pow` ``` motoko no-repl func pow(x : Int16, y : Int16) : Int16 @@ -369,12 +484,15 @@ Returns `x` to the power of `y`, `x ** y`. Traps on overflow/underflow and when `y < 0 or y >= 16`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.pow(2, 10) // => +1_024 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `**` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**` +as a function value at the moment. + ## Function `bitnot` ``` motoko no-repl func bitnot(x : Int16) : Int16 @@ -383,12 +501,15 @@ func bitnot(x : Int16) : Int16 Returns the bitwise negation of `x`, `^x`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitnot(-256 /* 0xff00 */) // => +255 // 0xff ``` +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitand` ``` motoko no-repl func bitand(x : Int16, y : Int16) : Int16 @@ -397,12 +518,15 @@ func bitand(x : Int16, y : Int16) : Int16 Returns the bitwise "and" of `x` and `y`, `x & y`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitand(0x0fff, 0x00f0) // => +240 // 0xf0 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `&` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `&` +as a function value at the moment. + ## Function `bitor` ``` motoko no-repl func bitor(x : Int16, y : Int16) : Int16 @@ -411,11 +535,13 @@ func bitor(x : Int16, y : Int16) : Int16 Returns the bitwise "or" of `x` and `y`, `x | y`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitor(0x0f0f, 0x00f0) // => +4_095 // 0x0fff ``` +Note: The reason why this function is defined in this library (in addition +to the existing `|` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `|` +as a function value at the moment. ## Function `bitxor` ``` motoko no-repl @@ -425,11 +551,13 @@ func bitxor(x : Int16, y : Int16) : Int16 Returns the bitwise "exclusive or" of `x` and `y`, `x ^ y`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitxor(0x0fff, 0x00f0) // => +3_855 // 0x0f0f ``` +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. ## Function `bitshiftLeft` ``` motoko no-repl @@ -444,12 +572,15 @@ For `y >= 16`, the semantics is the same as for `bitshiftLeft(x, y % 16)`. For `y < 0`, the semantics is the same as for `bitshiftLeft(x, y + y % 16)`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitshiftLeft(1, 8) // => +256 // 0x100 equivalent to `2 ** 8`. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<` +as a function value at the moment. + ## Function `bitshiftRight` ``` motoko no-repl func bitshiftRight(x : Int16, y : Int16) : Int16 @@ -463,12 +594,15 @@ For `y >= 16`, the semantics is the same as for `bitshiftRight(x, y % 16)`. For `y < 0`, the semantics is the same as for `bitshiftRight (x, y + y % 16)`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitshiftRight(1024, 8) // => +4 // equivalent to `1024 / (2 ** 8)` ``` +Note: The reason why this function is defined in this library (in addition +to the existing `>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>>` +as a function value at the moment. + ## Function `bitrotLeft` ``` motoko no-repl func bitrotLeft(x : Int16, y : Int16) : Int16 @@ -482,12 +616,15 @@ Changes the direction of rotation for negative `y`. For `y >= 16`, the semantics is the same as for `bitrotLeft(x, y % 16)`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitrotLeft(0x2001, 4) // => +18 // 0x12. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<<>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<>` +as a function value at the moment. + ## Function `bitrotRight` ``` motoko no-repl func bitrotRight(x : Int16, y : Int16) : Int16 @@ -501,12 +638,15 @@ Changes the direction of rotation for negative `y`. For `y >= 16`, the semantics is the same as for `bitrotRight(x, y % 16)`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitrotRight(0x2010, 8) // => +4_128 // 0x01020. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<>>` +as a function value at the moment. + ## Function `bittest` ``` motoko no-repl func bittest(x : Int16, p : Nat) : Bool @@ -514,11 +654,10 @@ func bittest(x : Int16, p : Nat) : Bool Returns the value of bit `p` in `x`, `x & 2**p == 2**p`. If `p >= 16`, the semantics is the same as for `bittest(x, p % 16)`. +This is equivalent to checking if the `p`-th bit is set in `x`, using 0 indexing. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bittest(128, 7) // => true ``` @@ -531,9 +670,7 @@ Returns the value of setting bit `p` in `x` to `1`. If `p >= 16`, the semantics is the same as for `bitset(x, p % 16)`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitset(0, 7) // => +128 ``` @@ -546,9 +683,7 @@ Returns the value of clearing bit `p` in `x` to `0`. If `p >= 16`, the semantics is the same as for `bitclear(x, p % 16)`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitclear(-1, 7) // => -129 ``` @@ -561,9 +696,7 @@ Returns the value of flipping bit `p` in `x`. If `p >= 16`, the semantics is the same as for `bitclear(x, p % 16)`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitflip(255, 7) // => +127 ``` @@ -575,9 +708,7 @@ let bitcountNonZero : (x : Int16) -> Int16 Returns the count of non-zero bits in `x`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitcountNonZero(0xff) // => +8 ``` @@ -589,9 +720,7 @@ let bitcountLeadingZero : (x : Int16) -> Int16 Returns the count of leading zero bits in `x`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitcountLeadingZero(0x80) // => +8 ``` @@ -603,9 +732,7 @@ let bitcountTrailingZero : (x : Int16) -> Int16 Returns the count of trailing zero bits in `x`. Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.bitcountTrailingZero(0x0100) // => +8 ``` @@ -618,14 +745,16 @@ Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow/underflow. - Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.addWrap(2 ** 14, 2 ** 14) // => -32_768 // overflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `+%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+%` +as a function value at the moment. + ## Function `subWrap` ``` motoko no-repl func subWrap(x : Int16, y : Int16) : Int16 @@ -635,14 +764,16 @@ Returns the difference of `x` and `y`, `x -% y`. Wraps on overflow/underflow. - Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.subWrap(-2 ** 15, 1) // => +32_767 // underflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `-%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-%` +as a function value at the moment. + ## Function `mulWrap` ``` motoko no-repl func mulWrap(x : Int16, y : Int16) : Int16 @@ -652,14 +783,16 @@ Returns the product of `x` and `y`, `x *% y`. Wraps on overflow. Wraps on overflow/underflow. - Example: -```motoko -import Int16 "mo:base/Int16"; - +```motoko include=import Int16.mulWrap(2 ** 8, 2 ** 8) // => 0 // overflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `*%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*%` +as a function value at the moment. + ## Function `powWrap` ``` motoko no-repl func powWrap(x : Int16, y : Int16) : Int16 @@ -670,10 +803,13 @@ Returns `x` to the power of `y`, `x **% y`. Wraps on overflow/underflow. Traps if `y < 0 or y >= 16`. - Example: -```motoko -import Int16 "mo:base/Int16"; +```motoko include=import Int16.powWrap(2, 15) // => -32_768 // overflow ``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**%` +as a function value at the moment. diff --git a/doc/md/base/Int32.md b/doc/md/base/Int32.md index b967d1bf1ff..a257a4917f0 100644 --- a/doc/md/base/Int32.md +++ b/doc/md/base/Int32.md @@ -1,8 +1,12 @@ # Int32 -32-bit signed integers with checked arithmetic. +Provides utility functions on 32-bit signed integers. -Common 32-bit integer functions. -Most operations are available as built-in operators (e.g. `1 + 1`). +Note that most operations are available as built-in operators (e.g. `1 + 1`). + +Import from the base library to use this module. +```motoko name=import +import Int32 "mo:base/Int32"; +``` ## Type `Int32` ``` motoko no-repl @@ -18,6 +22,11 @@ let minimumValue : Int32 Minimum 32-bit integer value, `-2 ** 31`. +Example: +```motoko include=import +Int32.minimumValue // => -2_147_483_648 +``` + ## Value `maximumValue` ``` motoko no-repl let maximumValue : Int32 @@ -25,6 +34,11 @@ let maximumValue : Int32 Maximum 32-bit integer value, `+2 ** 31 - 1`. +Example: +```motoko include=import +Int32.maximumValue // => +2_147_483_647 +``` + ## Value `toInt` ``` motoko no-repl let toInt : Int32 -> Int @@ -33,9 +47,7 @@ let toInt : Int32 -> Int Converts a 32-bit signed integer to a signed integer with infinite precision. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.toInt(123_456) // => 123_456 : Int ``` @@ -49,9 +61,7 @@ Converts a signed integer with infinite precision to a 32-bit signed integer. Traps on overflow/underflow. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.fromInt(123_456) // => +123_456 : Int32 ``` @@ -65,12 +75,62 @@ Converts a signed integer with infinite precision to a 32-bit signed integer. Wraps on overflow/underflow. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.fromIntWrap(-123_456) // => -123_456 : Int ``` +## Value `fromInt16` +``` motoko no-repl +let fromInt16 : Int16 -> Int32 +``` + +Converts a 16-bit signed integer to a 32-bit signed integer. + +Example: +```motoko include=import +Int32.fromInt16(-123) // => -123 : Int32 +``` + +## Value `toInt16` +``` motoko no-repl +let toInt16 : Int32 -> Int16 +``` + +Converts a 32-bit signed integer to a 16-bit signed integer. + +Traps on overflow/underflow. + +Example: +```motoko include=import +Int32.toInt16(-123) // => -123 : Int16 +``` + +## Value `fromInt64` +``` motoko no-repl +let fromInt64 : Int64 -> Int32 +``` + +Converts a 64-bit signed integer to a 32-bit signed integer. + +Traps on overflow/underflow. + +Example: +```motoko include=import +Int32.fromInt64(-123_456) // => -123_456 : Int32 +``` + +## Value `toInt64` +``` motoko no-repl +let toInt64 : Int32 -> Int64 +``` + +Converts a 32-bit signed integer to a 64-bit signed integer. + +Example: +```motoko include=import +Int32.toInt64(-123_456) // => -123_456 : Int64 +``` + ## Value `fromNat32` ``` motoko no-repl let fromNat32 : Nat32 -> Int32 @@ -81,9 +141,7 @@ Converts an unsigned 32-bit integer to a signed 32-bit integer. Wraps on overflow/underflow. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.fromNat32(123_456) // => +123_456 : Int32 ``` @@ -97,9 +155,7 @@ Converts a signed 32-bit integer to an unsigned 32-bit integer. Wraps on overflow/underflow. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.toNat32(-1) // => 4_294_967_295 : Nat32 // underflow ``` @@ -108,13 +164,11 @@ Int32.toNat32(-1) // => 4_294_967_295 : Nat32 // underflow func toText(x : Int32) : Text ``` -Returns the Text representation of `x`. -Formats the integer in decimal representation without underscore separators for thousand figures. +Returns the Text representation of `x`. Textual representation _do not_ +contain underscores to represent commas. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.toText(-123456) // => "-123456" ``` @@ -128,9 +182,7 @@ Returns the absolute value of `x`. Traps when `x == -2 ** 31` (the minimum `Int32` value). Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.abs(-123456) // => +123_456 ``` @@ -142,9 +194,7 @@ func min(x : Int32, y : Int32) : Int32 Returns the minimum of `x` and `y`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.min(+2, -3) // => -3 ``` @@ -156,9 +206,7 @@ func max(x : Int32, y : Int32) : Int32 Returns the maximum of `x` and `y`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.max(+2, -3) // => +2 ``` @@ -167,13 +215,28 @@ Int32.max(+2, -3) // => +2 func equal(x : Int32, y : Int32) : Bool ``` -Returns `x == y`. +Equality function for Int32 types. +This is equivalent to `x == y`. Example: -```motoko -import Int32 "mo:base/Int32"; +```motoko include=import +Int32.equal(-1, -1); // => true +``` -Int32.equal(123, 123) // => true +Note: The reason why this function is defined in this library (in addition +to the existing `==` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `==` +as a function value at the moment. + +Example: +```motoko include=import +import Buffer "mo:base/Buffer"; + +let buffer1 = Buffer.Buffer(1); +buffer1.add(-3); +let buffer2 = Buffer.Buffer(1); +buffer2.add(-3); +Buffer.equal(buffer1, buffer2, Int32.equal) // => true ``` ## Function `notEqual` @@ -181,83 +244,110 @@ Int32.equal(123, 123) // => true func notEqual(x : Int32, y : Int32) : Bool ``` -Returns `x != y`. +Inequality function for Int32 types. +This is equivalent to `x != y`. Example: -```motoko -import Int32 "mo:base/Int32"; - -Int32.notEqual(123, 123) // => false +```motoko include=import +Int32.notEqual(-1, -2); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `!=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `!=` +as a function value at the moment. + ## Function `less` ``` motoko no-repl func less(x : Int32, y : Int32) : Bool ``` -Returns `x < y`. +"Less than" function for Int32 types. +This is equivalent to `x < y`. Example: -```motoko -import Int32 "mo:base/Int32"; - -Int32.less(123, 1234) // => true +```motoko include=import +Int32.less(-2, 1); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<` +as a function value at the moment. + ## Function `lessOrEqual` ``` motoko no-repl func lessOrEqual(x : Int32, y : Int32) : Bool ``` -Returns `x <= y`. +"Less than or equal" function for Int32 types. +This is equivalent to `x <= y`. Example: -```motoko -import Int32 "mo:base/Int32"; - -Int32.lessOrEqual(123, 1234) // => true +```motoko include=import +Int32.lessOrEqual(-2, -2); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<=` +as a function value at the moment. + ## Function `greater` ``` motoko no-repl func greater(x : Int32, y : Int32) : Bool ``` -Returns `x > y`. +"Greater than" function for Int32 types. +This is equivalent to `x > y`. Example: -```motoko -import Int32 "mo:base/Int32"; - -Int32.greater(1234, 123) // => true +```motoko include=import +Int32.greater(-2, -3); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>` +as a function value at the moment. + ## Function `greaterOrEqual` ``` motoko no-repl func greaterOrEqual(x : Int32, y : Int32) : Bool ``` -Returns `x >= y`. +"Greater than or equal" function for Int32 types. +This is equivalent to `x >= y`. Example: -```motoko -import Int32 "mo:base/Int32"; - -Int32.greaterOrEqual(1234, 123) // => true +```motoko include=import +Int32.greaterOrEqual(-2, -2); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `>=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>=` +as a function value at the moment. + ## Function `compare` ``` motoko no-repl func compare(x : Int32, y : Int32) : {#less; #equal; #greater} ``` -Returns the order of `x` and `y`. +General-purpose comparison function for `Int32`. Returns the `Order` ( +either `#less`, `#equal`, or `#greater`) of comparing `x` with `y`. Example: -```motoko -import Int32 "mo:base/Int32"; +```motoko include=import +Int32.compare(-3, 2) // => #less +``` -Int32.compare(123, 1234) // => #less +This function can be used as value for a high order function, such as a sort function. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.sort([1, -2, -3] : [Int32], Int32.compare) // => [-3, -2, 1] ``` ## Function `neg` @@ -269,14 +359,16 @@ Returns the negation of `x`, `-x`. Traps on overflow, i.e. for `neg(-2 ** 31)`. - Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.neg(123) // => -123 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. + ## Function `add` ``` motoko no-repl func add(x : Int32, y : Int32) : Int32 @@ -287,10 +379,19 @@ Returns the sum of `x` and `y`, `x + y`. Traps on overflow/underflow. Example: -```motoko -import Int32 "mo:base/Int32"; +```motoko include=import +Int32.add(100, 23) // => +123 +``` -Int32.add(1234, 123) // => +1_357 +Note: The reason why this function is defined in this library (in addition +to the existing `+` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 0, Int32.add) // => -4 ``` ## Function `sub` @@ -303,12 +404,21 @@ Returns the difference of `x` and `y`, `x - y`. Traps on overflow/underflow. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.sub(1234, 123) // => +1_111 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 0, Int32.sub) // => 6 +``` + ## Function `mul` ``` motoko no-repl func mul(x : Int32, y : Int32) : Int32 @@ -319,12 +429,21 @@ Returns the product of `x` and `y`, `x * y`. Traps on overflow/underflow. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.mul(123, 100) // => +12_300 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `*` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 1, Int32.mul) // => 6 +``` + ## Function `div` ``` motoko no-repl func div(x : Int32, y : Int32) : Int32 @@ -336,12 +455,15 @@ Rounds the quotient towards zero, which is the same as truncating the decimal pl Traps when `y` is zero. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.div(123, 10) // => +12 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `/` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `/` +as a function value at the moment. + ## Function `rem` ``` motoko no-repl func rem(x : Int32, y : Int32) : Int32 @@ -353,12 +475,15 @@ which is defined as `x - x / y * y`. Traps when `y` is zero. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.rem(123, 10) // => +3 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `%` +as a function value at the moment. + ## Function `pow` ``` motoko no-repl func pow(x : Int32, y : Int32) : Int32 @@ -369,12 +494,15 @@ Returns `x` to the power of `y`, `x ** y`. Traps on overflow/underflow and when `y < 0 or y >= 32`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.pow(2, 10) // => +1_024 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `**` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**` +as a function value at the moment. + ## Function `bitnot` ``` motoko no-repl func bitnot(x : Int32) : Int32 @@ -383,12 +511,15 @@ func bitnot(x : Int32) : Int32 Returns the bitwise negation of `x`, `^x`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitnot(-256 /* 0xffff_ff00 */) // => +255 // 0xff ``` +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitand` ``` motoko no-repl func bitand(x : Int32, y : Int32) : Int32 @@ -397,12 +528,15 @@ func bitand(x : Int32, y : Int32) : Int32 Returns the bitwise "and" of `x` and `y`, `x & y`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitand(0xffff, 0x00f0) // => +240 // 0xf0 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `&` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `&` +as a function value at the moment. + ## Function `bitor` ``` motoko no-repl func bitor(x : Int32, y : Int32) : Int32 @@ -411,12 +545,15 @@ func bitor(x : Int32, y : Int32) : Int32 Returns the bitwise "or" of `x` and `y`, `x | y`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitor(0xffff, 0x00f0) // => +65_535 // 0xffff ``` +Note: The reason why this function is defined in this library (in addition +to the existing `|` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `|` +as a function value at the moment. + ## Function `bitxor` ``` motoko no-repl func bitxor(x : Int32, y : Int32) : Int32 @@ -425,12 +562,15 @@ func bitxor(x : Int32, y : Int32) : Int32 Returns the bitwise "exclusive or" of `x` and `y`, `x ^ y`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitxor(0xffff, 0x00f0) // => +65_295 // 0xff0f ``` +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitshiftLeft` ``` motoko no-repl func bitshiftLeft(x : Int32, y : Int32) : Int32 @@ -444,12 +584,15 @@ For `y >= 32`, the semantics is the same as for `bitshiftLeft(x, y % 32)`. For `y < 0`, the semantics is the same as for `bitshiftLeft(x, y + y % 32)`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitshiftLeft(1, 8) // => +256 // 0x100 equivalent to `2 ** 8`. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<` +as a function value at the moment. + ## Function `bitshiftRight` ``` motoko no-repl func bitshiftRight(x : Int32, y : Int32) : Int32 @@ -463,12 +606,15 @@ For `y >= 32`, the semantics is the same as for `bitshiftRight(x, y % 32)`. For `y < 0`, the semantics is the same as for `bitshiftRight (x, y + y % 32)`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitshiftRight(1024, 8) // => +4 // equivalent to `1024 / (2 ** 8)` ``` +Note: The reason why this function is defined in this library (in addition +to the existing `>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>>` +as a function value at the moment. + ## Function `bitrotLeft` ``` motoko no-repl func bitrotLeft(x : Int32, y : Int32) : Int32 @@ -482,12 +628,15 @@ Changes the direction of rotation for negative `y`. For `y >= 32`, the semantics is the same as for `bitrotLeft(x, y % 32)`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitrotLeft(0x2000_0001, 4) // => +18 // 0x12. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<<>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<>` +as a function value at the moment. + ## Function `bitrotRight` ``` motoko no-repl func bitrotRight(x : Int32, y : Int32) : Int32 @@ -501,12 +650,15 @@ Changes the direction of rotation for negative `y`. For `y >= 32`, the semantics is the same as for `bitrotRight(x, y % 32)`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitrotRight(0x0002_0001, 8) // => +16_777_728 // 0x0100_0200. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<>>` +as a function value at the moment. + ## Function `bittest` ``` motoko no-repl func bittest(x : Int32, p : Nat) : Bool @@ -514,11 +666,10 @@ func bittest(x : Int32, p : Nat) : Bool Returns the value of bit `p` in `x`, `x & 2**p == 2**p`. If `p >= 32`, the semantics is the same as for `bittest(x, p % 32)`. +This is equivalent to checking if the `p`-th bit is set in `x`, using 0 indexing. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bittest(128, 7) // => true ``` @@ -531,9 +682,7 @@ Returns the value of setting bit `p` in `x` to `1`. If `p >= 32`, the semantics is the same as for `bitset(x, p % 32)`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitset(0, 7) // => +128 ``` @@ -546,9 +695,7 @@ Returns the value of clearing bit `p` in `x` to `0`. If `p >= 32`, the semantics is the same as for `bitclear(x, p % 32)`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitclear(-1, 7) // => -129 ``` @@ -561,9 +708,7 @@ Returns the value of flipping bit `p` in `x`. If `p >= 32`, the semantics is the same as for `bitclear(x, p % 32)`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitflip(255, 7) // => +127 ``` @@ -575,9 +720,7 @@ let bitcountNonZero : (x : Int32) -> Int32 Returns the count of non-zero bits in `x`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitcountNonZero(0xffff) // => +16 ``` @@ -589,9 +732,7 @@ let bitcountLeadingZero : (x : Int32) -> Int32 Returns the count of leading zero bits in `x`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitcountLeadingZero(0x8000) // => +16 ``` @@ -603,9 +744,7 @@ let bitcountTrailingZero : (x : Int32) -> Int32 Returns the count of trailing zero bits in `x`. Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.bitcountTrailingZero(0x0201_0000) // => +16 ``` @@ -618,14 +757,16 @@ Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow/underflow. - Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.addWrap(2 ** 30, 2 ** 30) // => -2_147_483_648 // overflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `+%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+%` +as a function value at the moment. + ## Function `subWrap` ``` motoko no-repl func subWrap(x : Int32, y : Int32) : Int32 @@ -635,14 +776,16 @@ Returns the difference of `x` and `y`, `x -% y`. Wraps on overflow/underflow. - Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.subWrap(-2 ** 31, 1) // => +2_147_483_647 // underflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `-%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-%` +as a function value at the moment. + ## Function `mulWrap` ``` motoko no-repl func mulWrap(x : Int32, y : Int32) : Int32 @@ -652,14 +795,16 @@ Returns the product of `x` and `y`, `x *% y`. Wraps on overflow. Wraps on overflow/underflow. - Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.mulWrap(2 ** 16, 2 ** 16) // => 0 // overflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `*%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*%` +as a function value at the moment. + ## Function `powWrap` ``` motoko no-repl func powWrap(x : Int32, y : Int32) : Int32 @@ -670,10 +815,12 @@ Returns `x` to the power of `y`, `x **% y`. Wraps on overflow/underflow. Traps if `y < 0 or y >= 32`. - Example: -```motoko -import Int32 "mo:base/Int32"; - +```motoko include=import Int32.powWrap(2, 31) // => -2_147_483_648 // overflow ``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**%` +as a function value at the moment. diff --git a/doc/md/base/Int64.md b/doc/md/base/Int64.md index 62934851e48..1ded9b5fff1 100644 --- a/doc/md/base/Int64.md +++ b/doc/md/base/Int64.md @@ -1,8 +1,12 @@ # Int64 -64-bit signed integers with checked arithmetic. +Provides utility functions on 64-bit signed integers. -Common 64-bit integer functions. -Most operations are available as built-in operators (e.g. `1 + 1`). +Note that most operations are available as built-in operators (e.g. `1 + 1`). + +Import from the base library to use this module. +```motoko name=import +import Int64 "mo:base/Int64"; +``` ## Type `Int64` ``` motoko no-repl @@ -18,6 +22,11 @@ let minimumValue : Int64 Minimum 64-bit integer value, `-2 ** 63`. +Example: +```motoko include=import +Int64.minimumValue // => -9_223_372_036_854_775_808 +``` + ## Value `maximumValue` ``` motoko no-repl let maximumValue : Int64 @@ -25,6 +34,11 @@ let maximumValue : Int64 Maximum 64-bit integer value, `+2 ** 63 - 1`. +Example: +```motoko include=import +Int64.maximumValue // => +9_223_372_036_854_775_807 +``` + ## Value `toInt` ``` motoko no-repl let toInt : Int64 -> Int @@ -33,9 +47,7 @@ let toInt : Int64 -> Int Converts a 64-bit signed integer to a signed integer with infinite precision. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.toInt(123_456) // => 123_456 : Int ``` @@ -49,12 +61,38 @@ Converts a signed integer with infinite precision to a 64-bit signed integer. Traps on overflow/underflow. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.fromInt(123_456) // => +123_456 : Int64 ``` +## Value `fromInt32` +``` motoko no-repl +let fromInt32 : Int32 -> Int64 +``` + +Converts a 32-bit signed integer to a 64-bit signed integer. + +Traps on overflow/underflow. + +Example: +```motoko include=import +Int64.fromInt32(-123_456) // => -123_456 : Int64 +``` + +## Value `toInt32` +``` motoko no-repl +let toInt32 : Int64 -> Int32 +``` + +Converts a 64-bit signed integer to a 32-bit signed integer. + +Wraps on overflow/underflow. + +Example: +```motoko include=import +Int64.toInt32(-123_456) // => -123_456 : Int32 +``` + ## Value `fromIntWrap` ``` motoko no-repl let fromIntWrap : Int -> Int64 @@ -65,9 +103,7 @@ Converts a signed integer with infinite precision to a 64-bit signed integer. Wraps on overflow/underflow. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.fromIntWrap(-123_456) // => -123_456 : Int64 ``` @@ -81,9 +117,7 @@ Converts an unsigned 64-bit integer to a signed 64-bit integer. Wraps on overflow/underflow. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.fromNat64(123_456) // => +123_456 : Int64 ``` @@ -97,9 +131,7 @@ Converts a signed 64-bit integer to an unsigned 64-bit integer. Wraps on overflow/underflow. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.toNat64(-1) // => 18_446_744_073_709_551_615 : Nat64 // underflow ``` @@ -108,13 +140,12 @@ Int64.toNat64(-1) // => 18_446_744_073_709_551_615 : Nat64 // underflow func toText(x : Int64) : Text ``` -Returns the Text representation of `x`. -Formats the integer in decimal representation without underscore separators for thousand figures. +Returns the Text representation of `x`. Textual representation _do not_ +contain underscores to represent commas. -Example: -```motoko -import Int64 "mo:base/Int64"; +Example: +```motoko include=import Int64.toText(-123456) // => "-123456" ``` @@ -128,9 +159,7 @@ Returns the absolute value of `x`. Traps when `x == -2 ** 63` (the minimum `Int64` value). Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.abs(-123456) // => +123_456 ``` @@ -142,9 +171,7 @@ func min(x : Int64, y : Int64) : Int64 Returns the minimum of `x` and `y`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.min(+2, -3) // => -3 ``` @@ -156,9 +183,7 @@ func max(x : Int64, y : Int64) : Int64 Returns the maximum of `x` and `y`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.max(+2, -3) // => +2 ``` @@ -167,13 +192,28 @@ Int64.max(+2, -3) // => +2 func equal(x : Int64, y : Int64) : Bool ``` -Returns `x == y`. +Equality function for Int64 types. +This is equivalent to `x == y`. Example: -```motoko -import Int64 "mo:base/Int64"; +```motoko include=import +Int64.equal(-1, -1); // => true +``` -Int64.equal(123, 123) // => true +Note: The reason why this function is defined in this library (in addition +to the existing `==` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `==` +as a function value at the moment. + +Example: +```motoko include=import +import Buffer "mo:base/Buffer"; + +let buffer1 = Buffer.Buffer(1); +buffer1.add(-3); +let buffer2 = Buffer.Buffer(1); +buffer2.add(-3); +Buffer.equal(buffer1, buffer2, Int64.equal) // => true ``` ## Function `notEqual` @@ -181,83 +221,110 @@ Int64.equal(123, 123) // => true func notEqual(x : Int64, y : Int64) : Bool ``` -Returns `x != y`. +Inequality function for Int64 types. +This is equivalent to `x != y`. Example: -```motoko -import Int64 "mo:base/Int64"; - -Int64.notEqual(123, 123) // => false +```motoko include=import +Int64.notEqual(-1, -2); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `!=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `!=` +as a function value at the moment. + ## Function `less` ``` motoko no-repl func less(x : Int64, y : Int64) : Bool ``` -Returns `x < y`. +"Less than" function for Int64 types. +This is equivalent to `x < y`. Example: -```motoko -import Int64 "mo:base/Int64"; - -Int64.less(123, 1234) // => true +```motoko include=import +Int64.less(-2, 1); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<` +as a function value at the moment. + ## Function `lessOrEqual` ``` motoko no-repl func lessOrEqual(x : Int64, y : Int64) : Bool ``` -Returns `x <= y`. +"Less than or equal" function for Int64 types. +This is equivalent to `x <= y`. Example: -```motoko -import Int64 "mo:base/Int64"; - -Int64.lessOrEqual(123, 1234) // => true +```motoko include=import +Int64.lessOrEqual(-2, -2); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<=` +as a function value at the moment. + ## Function `greater` ``` motoko no-repl func greater(x : Int64, y : Int64) : Bool ``` -Returns `x > y`. +"Greater than" function for Int64 types. +This is equivalent to `x > y`. Example: -```motoko -import Int64 "mo:base/Int64"; - -Int64.greater(1234, 123) // => true +```motoko include=import +Int64.greater(-2, -3); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>` +as a function value at the moment. + ## Function `greaterOrEqual` ``` motoko no-repl func greaterOrEqual(x : Int64, y : Int64) : Bool ``` -Returns `x >= y`. +"Greater than or equal" function for Int64 types. +This is equivalent to `x >= y`. Example: -```motoko -import Int64 "mo:base/Int64"; - -Int64.greaterOrEqual(1234, 123) // => true +```motoko include=import +Int64.greaterOrEqual(-2, -2); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `>=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>=` +as a function value at the moment. + ## Function `compare` ``` motoko no-repl func compare(x : Int64, y : Int64) : {#less; #equal; #greater} ``` -Returns the order of `x` and `y`. +General-purpose comparison function for `Int64`. Returns the `Order` ( +either `#less`, `#equal`, or `#greater`) of comparing `x` with `y`. Example: -```motoko -import Int64 "mo:base/Int64"; +```motoko include=import +Int64.compare(-3, 2) // => #less +``` + +This function can be used as value for a high order function, such as a sort function. -Int64.compare(123, 1234) // => #less +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.sort([1, -2, -3] : [Int64], Int64.compare) // => [-3, -2, 1] ``` ## Function `neg` @@ -269,14 +336,16 @@ Returns the negation of `x`, `-x`. Traps on overflow, i.e. for `neg(-2 ** 63)`. - Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.neg(123) // => -123 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. + ## Function `add` ``` motoko no-repl func add(x : Int64, y : Int64) : Int64 @@ -287,12 +356,21 @@ Returns the sum of `x` and `y`, `x + y`. Traps on overflow/underflow. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.add(1234, 123) // => +1_357 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `+` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 0, Int64.add) // => -4 +``` + ## Function `sub` ``` motoko no-repl func sub(x : Int64, y : Int64) : Int64 @@ -303,10 +381,19 @@ Returns the difference of `x` and `y`, `x - y`. Traps on overflow/underflow. Example: -```motoko -import Int64 "mo:base/Int64"; +```motoko include=import +Int64.sub(123, 100) // => +23 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. -Int64.sub(1234, 123) // => +1_111 +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 0, Int64.sub) // => 4 ``` ## Function `mul` @@ -319,10 +406,19 @@ Returns the product of `x` and `y`, `x * y`. Traps on overflow/underflow. Example: -```motoko -import Int64 "mo:base/Int64"; +```motoko include=import +Int64.mul(123, 10) // => +1_230 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `*` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*` +as a function value at the moment. -Int64.mul(123, 100) // => +12_300 +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 1, Int64.mul) // => 6 ``` ## Function `div` @@ -336,12 +432,15 @@ Rounds the quotient towards zero, which is the same as truncating the decimal pl Traps when `y` is zero. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.div(123, 10) // => +12 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `/` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `/` +as a function value at the moment. + ## Function `rem` ``` motoko no-repl func rem(x : Int64, y : Int64) : Int64 @@ -353,12 +452,15 @@ which is defined as `x - x / y * y`. Traps when `y` is zero. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.rem(123, 10) // => +3 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `%` +as a function value at the moment. + ## Function `pow` ``` motoko no-repl func pow(x : Int64, y : Int64) : Int64 @@ -369,12 +471,15 @@ Returns `x` to the power of `y`, `x ** y`. Traps on overflow/underflow and when `y < 0 or y >= 64`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.pow(2, 10) // => +1_024 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `**` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**` +as a function value at the moment. + ## Function `bitnot` ``` motoko no-repl func bitnot(x : Int64) : Int64 @@ -383,12 +488,15 @@ func bitnot(x : Int64) : Int64 Returns the bitwise negation of `x`, `^x`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitnot(-256 /* 0xffff_ffff_ffff_ff00 */) // => +255 // 0xff ``` +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitand` ``` motoko no-repl func bitand(x : Int64, y : Int64) : Int64 @@ -397,12 +505,15 @@ func bitand(x : Int64, y : Int64) : Int64 Returns the bitwise "and" of `x` and `y`, `x & y`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitand(0xffff, 0x00f0) // => +240 // 0xf0 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `&` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `&` +as a function value at the moment. + ## Function `bitor` ``` motoko no-repl func bitor(x : Int64, y : Int64) : Int64 @@ -411,12 +522,15 @@ func bitor(x : Int64, y : Int64) : Int64 Returns the bitwise "or" of `x` and `y`, `x | y`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitor(0xffff, 0x00f0) // => +65_535 // 0xffff ``` +Note: The reason why this function is defined in this library (in addition +to the existing `|` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `|` +as a function value at the moment. + ## Function `bitxor` ``` motoko no-repl func bitxor(x : Int64, y : Int64) : Int64 @@ -425,12 +539,15 @@ func bitxor(x : Int64, y : Int64) : Int64 Returns the bitwise "exclusive or" of `x` and `y`, `x ^ y`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitxor(0xffff, 0x00f0) // => +65_295 // 0xff0f ``` +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitshiftLeft` ``` motoko no-repl func bitshiftLeft(x : Int64, y : Int64) : Int64 @@ -444,12 +561,15 @@ For `y >= 64`, the semantics is the same as for `bitshiftLeft(x, y % 64)`. For `y < 0`, the semantics is the same as for `bitshiftLeft(x, y + y % 64)`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitshiftLeft(1, 8) // => +256 // 0x100 equivalent to `2 ** 8`. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<` +as a function value at the moment. + ## Function `bitshiftRight` ``` motoko no-repl func bitshiftRight(x : Int64, y : Int64) : Int64 @@ -463,12 +583,15 @@ For `y >= 64`, the semantics is the same as for `bitshiftRight(x, y % 64)`. For `y < 0`, the semantics is the same as for `bitshiftRight (x, y + y % 64)`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitshiftRight(1024, 8) // => +4 // equivalent to `1024 / (2 ** 8)` ``` +Note: The reason why this function is defined in this library (in addition +to the existing `>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>>` +as a function value at the moment. + ## Function `bitrotLeft` ``` motoko no-repl func bitrotLeft(x : Int64, y : Int64) : Int64 @@ -482,12 +605,16 @@ Changes the direction of rotation for negative `y`. For `y >= 64`, the semantics is the same as for `bitrotLeft(x, y % 64)`. Example: -```motoko -import Int64 "mo:base/Int64"; +```motoko include=import Int64.bitrotLeft(0x2000_0000_0000_0001, 4) // => +18 // 0x12. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<<>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<>` +as a function value at the moment. + ## Function `bitrotRight` ``` motoko no-repl func bitrotRight(x : Int64, y : Int64) : Int64 @@ -501,12 +628,15 @@ Changes the direction of rotation for negative `y`. For `y >= 64`, the semantics is the same as for `bitrotRight(x, y % 64)`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitrotRight(0x0002_0000_0000_0001, 48) // => +65538 // 0x1_0002. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<>>` +as a function value at the moment. + ## Function `bittest` ``` motoko no-repl func bittest(x : Int64, p : Nat) : Bool @@ -514,11 +644,10 @@ func bittest(x : Int64, p : Nat) : Bool Returns the value of bit `p` in `x`, `x & 2**p == 2**p`. If `p >= 64`, the semantics is the same as for `bittest(x, p % 64)`. +This is equivalent to checking if the `p`-th bit is set in `x`, using 0 indexing. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bittest(128, 7) // => true ``` @@ -531,9 +660,7 @@ Returns the value of setting bit `p` in `x` to `1`. If `p >= 64`, the semantics is the same as for `bitset(x, p % 64)`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitset(0, 7) // => +128 ``` @@ -546,9 +673,7 @@ Returns the value of clearing bit `p` in `x` to `0`. If `p >= 64`, the semantics is the same as for `bitclear(x, p % 64)`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitclear(-1, 7) // => -129 ``` @@ -561,9 +686,7 @@ Returns the value of flipping bit `p` in `x`. If `p >= 64`, the semantics is the same as for `bitclear(x, p % 64)`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitflip(255, 7) // => +127 ``` @@ -575,9 +698,7 @@ let bitcountNonZero : (x : Int64) -> Int64 Returns the count of non-zero bits in `x`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitcountNonZero(0xffff) // => +16 ``` @@ -589,9 +710,7 @@ let bitcountLeadingZero : (x : Int64) -> Int64 Returns the count of leading zero bits in `x`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitcountLeadingZero(0x8000_0000) // => +32 ``` @@ -603,9 +722,7 @@ let bitcountTrailingZero : (x : Int64) -> Int64 Returns the count of trailing zero bits in `x`. Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.bitcountTrailingZero(0x0201_0000) // => +16 ``` @@ -618,14 +735,16 @@ Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow/underflow. - Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.addWrap(2 ** 62, 2 ** 62) // => -9_223_372_036_854_775_808 // overflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `+%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+%` +as a function value at the moment. + ## Function `subWrap` ``` motoko no-repl func subWrap(x : Int64, y : Int64) : Int64 @@ -635,14 +754,16 @@ Returns the difference of `x` and `y`, `x -% y`. Wraps on overflow/underflow. - Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.subWrap(-2 ** 63, 1) // => +9_223_372_036_854_775_807 // underflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `-%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-%` +as a function value at the moment. + ## Function `mulWrap` ``` motoko no-repl func mulWrap(x : Int64, y : Int64) : Int64 @@ -652,14 +773,16 @@ Returns the product of `x` and `y`, `x *% y`. Wraps on overflow. Wraps on overflow/underflow. - Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.mulWrap(2 ** 32, 2 ** 32) // => 0 // overflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `*%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*%` +as a function value at the moment. + ## Function `powWrap` ``` motoko no-repl func powWrap(x : Int64, y : Int64) : Int64 @@ -670,10 +793,12 @@ Returns `x` to the power of `y`, `x **% y`. Wraps on overflow/underflow. Traps if `y < 0 or y >= 64`. - Example: -```motoko -import Int64 "mo:base/Int64"; - +```motoko include=import Int64.powWrap(2, 63) // => -9_223_372_036_854_775_808 // overflow ``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**%` +as a function value at the moment. diff --git a/doc/md/base/Int8.md b/doc/md/base/Int8.md index c2f27f8783a..036e188a0ba 100644 --- a/doc/md/base/Int8.md +++ b/doc/md/base/Int8.md @@ -1,8 +1,12 @@ # Int8 -8-bit signed integers with checked arithmetic. +Provides utility functions on 8-bit signed integers. -Common 8-bit integer functions. -Most operations are available as built-in operators (e.g. `1 + 1`). +Note that most operations are available as built-in operators (e.g. `1 + 1`). + +Import from the base library to use this module. +```motoko name=import +import Int8 "mo:base/Int8"; +``` ## Type `Int8` ``` motoko no-repl @@ -18,6 +22,11 @@ let minimumValue : Int8 Minimum 8-bit integer value, `-2 ** 7`. +Example: +```motoko include=import +Int8.minimumValue // => -128 +``` + ## Value `maximumValue` ``` motoko no-repl let maximumValue : Int8 @@ -25,17 +34,20 @@ let maximumValue : Int8 Maximum 8-bit integer value, `+2 ** 7 - 1`. +Example: +```motoko include=import +Int8.maximumValue // => +127 +``` + ## Value `toInt` ``` motoko no-repl let toInt : Int8 -> Int ``` -Converts a 8-bit signed integer to a signed integer with infinite precision. +Converts an 8-bit signed integer to a signed integer with infinite precision. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.toInt(123) // => 123 : Int ``` @@ -44,14 +56,12 @@ Int8.toInt(123) // => 123 : Int let fromInt : Int -> Int8 ``` -Converts a signed integer with infinite precision to a 8-bit signed integer. +Converts a signed integer with infinite precision to an 8-bit signed integer. Traps on overflow/underflow. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.fromInt(123) // => +123 : Int8 ``` @@ -60,17 +70,41 @@ Int8.fromInt(123) // => +123 : Int8 let fromIntWrap : Int -> Int8 ``` -Converts a signed integer with infinite precision to a 8-bit signed integer. +Converts a signed integer with infinite precision to an 8-bit signed integer. Wraps on overflow/underflow. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.fromIntWrap(-123) // => -123 : Int ``` +## Value `fromInt16` +``` motoko no-repl +let fromInt16 : Int16 -> Int8 +``` + +Converts a 16-bit signed integer to an 8-bit signed integer. + +Traps on overflow/underflow. + +Example: +```motoko include=import +Int8.fromInt16(123) // => +123 : Int8 +``` + +## Value `toInt16` +``` motoko no-repl +let toInt16 : Int8 -> Int16 +``` + +Converts an 8-bit signed integer to a 16-bit signed integer. + +Example: +```motoko include=import +Int8.toInt16(123) // => +123 : Int16 +``` + ## Value `fromNat8` ``` motoko no-repl let fromNat8 : Nat8 -> Int8 @@ -81,9 +115,7 @@ Converts an unsigned 8-bit integer to a signed 8-bit integer. Wraps on overflow/underflow. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.fromNat8(123) // => +123 : Int8 ``` @@ -97,9 +129,7 @@ Converts a signed 8-bit integer to an unsigned 8-bit integer. Wraps on overflow/underflow. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.toNat8(-1) // => 255 : Nat8 // underflow ``` @@ -108,13 +138,10 @@ Int8.toNat8(-1) // => 255 : Nat8 // underflow func toText(x : Int8) : Text ``` -Returns the Text representation of `x`. -Formats the integer in decimal representation. +Converts an integer number to its textual representation. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.toText(-123) // => "-123" ``` @@ -128,9 +155,7 @@ Returns the absolute value of `x`. Traps when `x == -2 ** 7` (the minimum `Int8` value). Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.abs(-123) // => +123 ``` @@ -142,9 +167,7 @@ func min(x : Int8, y : Int8) : Int8 Returns the minimum of `x` and `y`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.min(+2, -3) // => -3 ``` @@ -156,9 +179,7 @@ func max(x : Int8, y : Int8) : Int8 Returns the maximum of `x` and `y`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.max(+2, -3) // => +2 ``` @@ -167,13 +188,28 @@ Int8.max(+2, -3) // => +2 func equal(x : Int8, y : Int8) : Bool ``` -Returns `x == y`. +Equality function for Int8 types. +This is equivalent to `x == y`. Example: -```motoko -import Int8 "mo:base/Int8"; +```motoko include=import +Int8.equal(-1, -1); // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `==` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `==` +as a function value at the moment. + +Example: +```motoko include=import +import Buffer "mo:base/Buffer"; -Int8.equal(123, 123) // => true +let buffer1 = Buffer.Buffer(1); +buffer1.add(-3); +let buffer2 = Buffer.Buffer(1); +buffer2.add(-3); +Buffer.equal(buffer1, buffer2, Int8.equal) // => true ``` ## Function `notEqual` @@ -181,83 +217,110 @@ Int8.equal(123, 123) // => true func notEqual(x : Int8, y : Int8) : Bool ``` -Returns `x != y`. +Inequality function for Int8 types. +This is equivalent to `x != y`. Example: -```motoko -import Int8 "mo:base/Int8"; - -Int8.notEqual(123, 123) // => false +```motoko include=import +Int8.notEqual(-1, -2); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `!=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `!=` +as a function value at the moment. + ## Function `less` ``` motoko no-repl func less(x : Int8, y : Int8) : Bool ``` -Returns `x < y`. +"Less than" function for Int8 types. +This is equivalent to `x < y`. Example: -```motoko -import Int8 "mo:base/Int8"; - -Int8.less(123, 124) // => true +```motoko include=import +Int8.less(-2, 1); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<` +as a function value at the moment. + ## Function `lessOrEqual` ``` motoko no-repl func lessOrEqual(x : Int8, y : Int8) : Bool ``` -Returns `x <= y`. +"Less than or equal" function for Int8 types. +This is equivalent to `x <= y`. Example: -```motoko -import Int8 "mo:base/Int8"; - -Int8.lessOrEqual(123, 124) // => true +```motoko include=import +Int8.lessOrEqual(-2, -2); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<=` +as a function value at the moment. + ## Function `greater` ``` motoko no-repl func greater(x : Int8, y : Int8) : Bool ``` -Returns `x > y`. +"Greater than" function for Int8 types. +This is equivalent to `x > y`. Example: -```motoko -import Int8 "mo:base/Int8"; - -Int8.greater(124, 123) // => true +```motoko include=import +Int8.greater(-2, -3); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>` +as a function value at the moment. + ## Function `greaterOrEqual` ``` motoko no-repl func greaterOrEqual(x : Int8, y : Int8) : Bool ``` -Returns `x >= y`. +"Greater than or equal" function for Int8 types. +This is equivalent to `x >= y`. Example: -```motoko -import Int8 "mo:base/Int8"; - -Int8.greaterOrEqual(124, 123) // => true +```motoko include=import +Int8.greaterOrEqual(-2, -2); // => true ``` +Note: The reason why this function is defined in this library (in addition +to the existing `>=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>=` +as a function value at the moment. + ## Function `compare` ``` motoko no-repl func compare(x : Int8, y : Int8) : {#less; #equal; #greater} ``` -Returns the order of `x` and `y`. +General-purpose comparison function for `Int8`. Returns the `Order` ( +either `#less`, `#equal`, or `#greater`) of comparing `x` with `y`. Example: -```motoko -import Int8 "mo:base/Int8"; +```motoko include=import +Int8.compare(-3, 2) // => #less +``` -Int8.compare(123, 124) // => #less +This function can be used as value for a high order function, such as a sort function. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.sort([1, -2, -3] : [Int8], Int8.compare) // => [-3, -2, 1] ``` ## Function `neg` @@ -269,14 +332,16 @@ Returns the negation of `x`, `-x`. Traps on overflow, i.e. for `neg(-2 ** 7)`. - Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.neg(123) // => -123 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. + ## Function `add` ``` motoko no-repl func add(x : Int8, y : Int8) : Int8 @@ -287,12 +352,21 @@ Returns the sum of `x` and `y`, `x + y`. Traps on overflow/underflow. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.add(100, 23) // => +123 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `+` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 0, Int8.add) // => -4 +``` + ## Function `sub` ``` motoko no-repl func sub(x : Int8, y : Int8) : Int8 @@ -303,12 +377,21 @@ Returns the difference of `x` and `y`, `x - y`. Traps on overflow/underflow. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.sub(123, 23) // => +100 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 0, Int8.sub) // => 4 +``` + ## Function `mul` ``` motoko no-repl func mul(x : Int8, y : Int8) : Int8 @@ -319,12 +402,21 @@ Returns the product of `x` and `y`, `x * y`. Traps on overflow/underflow. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.mul(12, 10) // => +120 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `*` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([1, -2, -3], 1, Int8.mul) // => 6 +``` + ## Function `div` ``` motoko no-repl func div(x : Int8, y : Int8) : Int8 @@ -336,12 +428,15 @@ Rounds the quotient towards zero, which is the same as truncating the decimal pl Traps when `y` is zero. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.div(123, 10) // => +12 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `/` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `/` +as a function value at the moment. + ## Function `rem` ``` motoko no-repl func rem(x : Int8, y : Int8) : Int8 @@ -353,12 +448,15 @@ which is defined as `x - x / y * y`. Traps when `y` is zero. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.rem(123, 10) // => +3 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `%` +as a function value at the moment. + ## Function `pow` ``` motoko no-repl func pow(x : Int8, y : Int8) : Int8 @@ -369,12 +467,15 @@ Returns `x` to the power of `y`, `x ** y`. Traps on overflow/underflow and when `y < 0 or y >= 8`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.pow(2, 6) // => +64 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `**` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**` +as a function value at the moment. + ## Function `bitnot` ``` motoko no-repl func bitnot(x : Int8) : Int8 @@ -383,12 +484,15 @@ func bitnot(x : Int8) : Int8 Returns the bitwise negation of `x`, `^x`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitnot(-16 /* 0xf0 */) // => +15 // 0x0f ``` +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitand` ``` motoko no-repl func bitand(x : Int8, y : Int8) : Int8 @@ -397,12 +501,15 @@ func bitand(x : Int8, y : Int8) : Int8 Returns the bitwise "and" of `x` and `y`, `x & y`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitand(0x1f, 0x70) // => +16 // 0x10 ``` +Note: The reason why this function is defined in this library (in addition +to the existing `&` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `&` +as a function value at the moment. + ## Function `bitor` ``` motoko no-repl func bitor(x : Int8, y : Int8) : Int8 @@ -411,12 +518,15 @@ func bitor(x : Int8, y : Int8) : Int8 Returns the bitwise "or" of `x` and `y`, `x | y`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitor(0x0f, 0x70) // => +127 // 0x7f ``` +Note: The reason why this function is defined in this library (in addition +to the existing `|` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `|` +as a function value at the moment. + ## Function `bitxor` ``` motoko no-repl func bitxor(x : Int8, y : Int8) : Int8 @@ -425,12 +535,15 @@ func bitxor(x : Int8, y : Int8) : Int8 Returns the bitwise "exclusive or" of `x` and `y`, `x ^ y`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitxor(0x70, 0x7f) // => +15 // 0x0f ``` +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitshiftLeft` ``` motoko no-repl func bitshiftLeft(x : Int8, y : Int8) : Int8 @@ -444,12 +557,15 @@ For `y >= 8`, the semantics is the same as for `bitshiftLeft(x, y % 8)`. For `y < 0`, the semantics is the same as for `bitshiftLeft(x, y + y % 8)`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitshiftLeft(1, 4) // => +16 // 0x10 equivalent to `2 ** 4`. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<` +as a function value at the moment. + ## Function `bitshiftRight` ``` motoko no-repl func bitshiftRight(x : Int8, y : Int8) : Int8 @@ -463,12 +579,15 @@ For `y >= 8`, the semantics is the same as for `bitshiftRight(x, y % 8)`. For `y < 0`, the semantics is the same as for `bitshiftRight (x, y + y % 8)`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitshiftRight(64, 4) // => +4 // equivalent to `64 / (2 ** 4)` ``` +Note: The reason why this function is defined in this library (in addition +to the existing `>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>>` +as a function value at the moment. + ## Function `bitrotLeft` ``` motoko no-repl func bitrotLeft(x : Int8, y : Int8) : Int8 @@ -482,12 +601,15 @@ Changes the direction of rotation for negative `y`. For `y >= 8`, the semantics is the same as for `bitrotLeft(x, y % 8)`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitrotLeft(0x11 /* 0b0001_0001 */, 2) // => +68 // 0b0100_0100 == 0x44. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<<>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<>` +as a function value at the moment. + ## Function `bitrotRight` ``` motoko no-repl func bitrotRight(x : Int8, y : Int8) : Int8 @@ -501,12 +623,15 @@ Changes the direction of rotation for negative `y`. For `y >= 8`, the semantics is the same as for `bitrotRight(x, y % 8)`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitrotRight(0x11 /* 0b0001_0001 */, 1) // => -120 // 0b1000_1000 == 0x88. ``` +Note: The reason why this function is defined in this library (in addition +to the existing `<>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<>>` +as a function value at the moment. + ## Function `bittest` ``` motoko no-repl func bittest(x : Int8, p : Nat) : Bool @@ -514,11 +639,10 @@ func bittest(x : Int8, p : Nat) : Bool Returns the value of bit `p` in `x`, `x & 2**p == 2**p`. If `p >= 8`, the semantics is the same as for `bittest(x, p % 8)`. +This is equivalent to checking if the `p`-th bit is set in `x`, using 0 indexing. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bittest(64, 6) // => true ``` @@ -531,9 +655,7 @@ Returns the value of setting bit `p` in `x` to `1`. If `p >= 8`, the semantics is the same as for `bitset(x, p % 8)`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitset(0, 6) // => +64 ``` @@ -546,9 +668,7 @@ Returns the value of clearing bit `p` in `x` to `0`. If `p >= 8`, the semantics is the same as for `bitclear(x, p % 8)`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitclear(-1, 6) // => -65 ``` @@ -561,9 +681,7 @@ Returns the value of flipping bit `p` in `x`. If `p >= 8`, the semantics is the same as for `bitclear(x, p % 8)`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitflip(127, 6) // => +63 ``` @@ -575,9 +693,7 @@ let bitcountNonZero : (x : Int8) -> Int8 Returns the count of non-zero bits in `x`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitcountNonZero(0x0f) // => +4 ``` @@ -589,9 +705,7 @@ let bitcountLeadingZero : (x : Int8) -> Int8 Returns the count of leading zero bits in `x`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitcountLeadingZero(0x08) // => +4 ``` @@ -603,9 +717,7 @@ let bitcountTrailingZero : (x : Int8) -> Int8 Returns the count of trailing zero bits in `x`. Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.bitcountTrailingZero(0x10) // => +4 ``` @@ -618,14 +730,16 @@ Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow/underflow. - Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.addWrap(2 ** 6, 2 ** 6) // => -128 // overflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `+%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+%` +as a function value at the moment. + ## Function `subWrap` ``` motoko no-repl func subWrap(x : Int8, y : Int8) : Int8 @@ -635,14 +749,16 @@ Returns the difference of `x` and `y`, `x -% y`. Wraps on overflow/underflow. - Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.subWrap(-2 ** 7, 1) // => +127 // underflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `-%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-%` +as a function value at the moment. + ## Function `mulWrap` ``` motoko no-repl func mulWrap(x : Int8, y : Int8) : Int8 @@ -652,14 +768,16 @@ Returns the product of `x` and `y`, `x *% y`. Wraps on overflow. Wraps on overflow/underflow. - Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.mulWrap(2 ** 4, 2 ** 4) // => 0 // overflow ``` +Note: The reason why this function is defined in this library (in addition +to the existing `*%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*%` +as a function value at the moment. + ## Function `powWrap` ``` motoko no-repl func powWrap(x : Int8, y : Int8) : Int8 @@ -670,10 +788,12 @@ Returns `x` to the power of `y`, `x **% y`. Wraps on overflow/underflow. Traps if `y < 0 or y >= 8`. - Example: -```motoko -import Int8 "mo:base/Int8"; - +```motoko include=import Int8.powWrap(2, 7) // => -128 // overflow ``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**%` +as a function value at the moment. diff --git a/doc/md/base/Iter.md b/doc/md/base/Iter.md index 81bcdf106ac..280190e1e08 100644 --- a/doc/md/base/Iter.md +++ b/doc/md/base/Iter.md @@ -108,7 +108,7 @@ func filter(xs : Iter, f : A -> Bool) : Iter Takes a function and an iterator and returns a new iterator that produces elements from the original iterator if and only if the predicate is true. ```motoko -import Iter "o:base/Iter"; +import Iter "mo:base/Iter"; let iter = Iter.range(1, 3); let mappedIter = Iter.filter(iter, func (x : Nat) : Bool { x % 2 == 1 }); assert(?1 == mappedIter.next()); @@ -131,6 +131,25 @@ assert(?10 == iter.next()); // ... ``` +## Function `concat` +``` motoko no-repl +func concat(a : Iter, b : Iter) : Iter +``` + +Takes two iterators and returns a new iterator that produces +elements from the original iterators sequentally. +```motoko +import Iter "mo:base/Iter"; +let iter1 = Iter.range(1, 2); +let iter2 = Iter.range(5, 6); +let concatenatedIter = Iter.concat(iter1, iter2); +assert(?1 == concatenatedIter.next()); +assert(?2 == concatenatedIter.next()); +assert(?5 == concatenatedIter.next()); +assert(?6 == concatenatedIter.next()); +assert(null == concatenatedIter.next()); +``` + ## Function `fromArray` ``` motoko no-repl func fromArray(xs : [A]) : Iter diff --git a/doc/md/base/List.md b/doc/md/base/List.md index c783d956119..a31770bf1b3 100644 --- a/doc/md/base/List.md +++ b/doc/md/base/List.md @@ -162,7 +162,9 @@ sum // => 3 Runtime: O(size) -Space: O(1) +Space: O(size) + +*Runtime and space assumes that `f` runs in O(1) time and space. ## Function `map` ``` motoko no-repl @@ -219,6 +221,8 @@ Runtime: O(size) Space: O(size) +*Runtime and space assumes that `f` runs in O(1) time and space. + ## Function `mapFilter` ``` motoko no-repl func mapFilter(l : List, f : T -> ?U) : List @@ -245,6 +249,8 @@ Runtime: O(size) Space: O(size) +*Runtime and space assumes that `f` runs in O(1) time and space. + ## Function `mapResult` ``` motoko no-repl func mapResult(xs : List, f : T -> Result.Result) : Result.Result, E> @@ -654,7 +660,7 @@ Runtime: O(min(size(xs), size(ys))) Space: O(min(size(xs), size(ys))) -*Runtime and space assumes that `zip` runs in O(1) time and space. +*Runtime and space assumes that `f` runs in O(1) time and space. ## Function `split` ``` motoko no-repl @@ -675,8 +681,6 @@ Runtime: O(n) Space: O(n) -*Runtime and space assumes that `zip` runs in O(1) time and space. - ## Function `chunks` ``` motoko no-repl func chunks(n : Nat, xs : List) : List> @@ -703,8 +707,6 @@ Runtime: O(size) Space: O(size) -*Runtime and space assumes that `zip` runs in O(1) time and space. - ## Function `fromArray` ``` motoko no-repl func fromArray(xs : [T]) : List diff --git a/doc/md/base/Nat.md b/doc/md/base/Nat.md index e30877af69b..384b64c92a3 100644 --- a/doc/md/base/Nat.md +++ b/doc/md/base/Nat.md @@ -347,3 +347,41 @@ Note: The reason why this function is defined in this library (in addition to the existing `**` operator) is so that you can use it as a function value to pass to a higher order function. It is not possible to use `**` as a function value at the moment. + +## Function `bitshiftLeft` +``` motoko no-repl +func bitshiftLeft(x : Nat, y : Nat32) : Nat +``` + +Returns the (conceptual) bitwise shift left of `x` by `y`, `x * (2 ** y)`. + +Example: +```motoko include=import +Nat.bitshiftLeft(1, 3); // => 8 +``` + +Note: The reason why this function is defined in this library (in absence +of the `<<` operator) is so that you can use it as a function +value to pass to a higher order function. While `Nat` is not defined in terms +of bit patterns, conceptually it can be regarded as such, and the operation +is provided as a high-performance version of the corresponding arithmetic +rule. + +## Function `bitshiftRight` +``` motoko no-repl +func bitshiftRight(x : Nat, y : Nat32) : Nat +``` + +Returns the (conceptual) bitwise shift right of `x` by `y`, `x / (2 ** y)`. + +Example: +```motoko include=import +Nat.bitshiftRight(8, 3); // => 1 +``` + +Note: The reason why this function is defined in this library (in absence +of the `>>` operator) is so that you can use it as a function +value to pass to a higher order function. While `Nat` is not defined in terms +of bit patterns, conceptually it can be regarded as such, and the operation +is provided as a high-performance version of the corresponding arithmetic +rule. diff --git a/doc/md/base/Nat16.md b/doc/md/base/Nat16.md index 713000b2e98..1d011098f20 100644 --- a/doc/md/base/Nat16.md +++ b/doc/md/base/Nat16.md @@ -1,7 +1,12 @@ # Nat16 -16-bit unsigned integers with checked arithmetic +Provides utility functions on 16-bit unsigned integers. -Most operations are available as built-in operators (e.g. `1 + 1`). +Note that most operations are available as built-in operators (e.g. `1 + 1`). + +Import from the base library to use this module. +```motoko name=import +import Nat16 "mo:base/Nat16"; +``` ## Type `Nat16` ``` motoko no-repl @@ -10,33 +15,122 @@ type Nat16 = Prim.Types.Nat16 16-bit natural numbers. +## Value `maximumValue` +``` motoko no-repl +let maximumValue : Nat16 +``` + +Maximum 16-bit natural number. `2 ** 16 - 1`. + +Example: +```motoko include=import +Nat16.maximumValue; // => 65536 : Nat16 +``` + ## Value `toNat` ``` motoko no-repl let toNat : Nat16 -> Nat ``` -Conversion. +Converts a 16-bit unsigned integer to an unsigned integer with infinite precision. + +Example: +```motoko include=import +Nat16.toNat(123); // => 123 : Nat +``` ## Value `fromNat` ``` motoko no-repl let fromNat : Nat -> Nat16 ``` -Conversion. Traps on overflow/underflow. +Converts an unsigned integer with infinite precision to a 16-bit unsigned integer. + +Traps on overflow. + +Example: +```motoko include=import +Nat16.fromNat(123); // => 123 : Nat16 +``` + +## Function `fromNat8` +``` motoko no-repl +func fromNat8(x : Nat8) : Nat16 +``` + +Converts an 8-bit unsigned integer to a 16-bit unsigned integer. + +Example: +```motoko include=import +Nat16.fromNat8(123); // => 123 : Nat16 +``` + +## Function `toNat8` +``` motoko no-repl +func toNat8(x : Nat16) : Nat8 +``` + +Converts a 16-bit unsigned integer to an 8-bit unsigned integer. + +Traps on overflow. + +Example: +```motoko include=import +Nat16.toNat8(123); // => 123 : Nat8 +``` + +## Function `fromNat32` +``` motoko no-repl +func fromNat32(x : Nat32) : Nat16 +``` + +Converts a 32-bit unsigned integer to a 16-bit unsigned integer. + +Traps on overflow. + +Example: +```motoko include=import +Nat16.fromNat32(123); // => 123 : Nat16 +``` + +## Function `toNat32` +``` motoko no-repl +func toNat32(x : Nat16) : Nat32 +``` + +Converts a 16-bit unsigned integer to a 32-bit unsigned integer. + +Example: +```motoko include=import +Nat16.toNat32(123); // => 123 : Nat32 +``` ## Value `fromIntWrap` ``` motoko no-repl let fromIntWrap : Int -> Nat16 ``` -Conversion. Wraps on overflow/underflow. +Converts a signed integer with infinite precision to a 16-bit unsigned integer. + +Wraps on overflow/underflow. + +Example: +```motoko include=import +Nat16.fromIntWrap(123 : Int); // => 123 : Nat16 +``` ## Function `toText` ``` motoko no-repl func toText(x : Nat16) : Text ``` -Returns the Text representation of `x`. +Converts `x` to its textual representation. Textual representation _do not_ +contain underscores to represent commas. + +Example: +```motoko include=import +Nat16.toText(1234); // => "1234" : Text +``` ## Function `min` ``` motoko no-repl @@ -45,6 +139,11 @@ func min(x : Nat16, y : Nat16) : Nat16 Returns the minimum of `x` and `y`. +Example: +```motoko include=import +Nat16.min(123, 200); // => 123 : Nat16 +``` + ## Function `max` ``` motoko no-repl func max(x : Nat16, y : Nat16) : Nat16 @@ -52,84 +151,249 @@ func max(x : Nat16, y : Nat16) : Nat16 Returns the maximum of `x` and `y`. +Example: +```motoko include=import +Nat16.max(123, 200); // => 200 : Nat16 +``` + ## Function `equal` ``` motoko no-repl func equal(x : Nat16, y : Nat16) : Bool ``` -Returns `x == y`. +Equality function for Nat16 types. +This is equivalent to `x == y`. + +Example: +```motoko include=import +ignore Nat16.equal(1, 1); // => true +(1 : Nat16) == (1 : Nat16) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `==` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `==` +as a function value at the moment. + +Example: +```motoko include=import +import Buffer "mo:base/Buffer"; + +let buffer1 = Buffer.Buffer(3); +let buffer2 = Buffer.Buffer(3); +Buffer.equal(buffer1, buffer2, Nat16.equal) // => true +``` ## Function `notEqual` ``` motoko no-repl func notEqual(x : Nat16, y : Nat16) : Bool ``` -Returns `x != y`. +Inequality function for Nat16 types. +This is equivalent to `x != y`. + +Example: +```motoko include=import +ignore Nat16.notEqual(1, 2); // => true +(1 : Nat16) != (2 : Nat16) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `!=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `!=` +as a function value at the moment. ## Function `less` ``` motoko no-repl func less(x : Nat16, y : Nat16) : Bool ``` -Returns `x < y`. +"Less than" function for Nat16 types. +This is equivalent to `x < y`. + +Example: +```motoko include=import +ignore Nat16.less(1, 2); // => true +(1 : Nat16) < (2 : Nat16) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<` +as a function value at the moment. ## Function `lessOrEqual` ``` motoko no-repl func lessOrEqual(x : Nat16, y : Nat16) : Bool ``` -Returns `x <= y`. +"Less than or equal" function for Nat16 types. +This is equivalent to `x <= y`. + +Example: +```motoko include=import +ignore Nat16.lessOrEqual(1, 2); // => true +(1 : Nat16) <= (2 : Nat16) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<=` +as a function value at the moment. ## Function `greater` ``` motoko no-repl func greater(x : Nat16, y : Nat16) : Bool ``` -Returns `x > y`. +"Greater than" function for Nat16 types. +This is equivalent to `x > y`. + +Example: +```motoko include=import +ignore Nat16.greater(2, 1); // => true +(2 : Nat16) > (1 : Nat16) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>` +as a function value at the moment. ## Function `greaterOrEqual` ``` motoko no-repl func greaterOrEqual(x : Nat16, y : Nat16) : Bool ``` -Returns `x >= y`. +"Greater than or equal" function for Nat16 types. +This is equivalent to `x >= y`. + +Example: +```motoko include=import +ignore Nat16.greaterOrEqual(2, 1); // => true +(2 : Nat16) >= (1 : Nat16) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>=` +as a function value at the moment. ## Function `compare` ``` motoko no-repl func compare(x : Nat16, y : Nat16) : {#less; #equal; #greater} ``` -Returns the order of `x` and `y`. +General purpose comparison function for `Nat16`. Returns the `Order` ( +either `#less`, `#equal`, or `#greater`) of comparing `x` with `y`. + +Example: +```motoko include=import +Nat16.compare(2, 3) // => #less +``` + +This function can be used as value for a high order function, such as a sort function. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.sort([2, 3, 1] : [Nat16], Nat16.compare) // => [1, 2, 3] +``` ## Function `add` ``` motoko no-repl func add(x : Nat16, y : Nat16) : Nat16 ``` -Returns the sum of `x` and `y`, `x + y`. Traps on overflow. +Returns the sum of `x` and `y`, `x + y`. +Traps on overflow. + +Example: +```motoko include=import +ignore Nat16.add(1, 2); // => 3 +(1 : Nat16) + (2 : Nat16) // => 3 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `+` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 0, Nat16.add) // => 6 +``` ## Function `sub` ``` motoko no-repl func sub(x : Nat16, y : Nat16) : Nat16 ``` -Returns the difference of `x` and `y`, `x - y`. Traps on underflow. +Returns the difference of `x` and `y`, `x - y`. +Traps on underflow. + +Example: +```motoko include=import +ignore Nat16.sub(2, 1); // => 1 +(2 : Nat16) - (1 : Nat16) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 20, Nat16.sub) // => 14 +``` ## Function `mul` ``` motoko no-repl func mul(x : Nat16, y : Nat16) : Nat16 ``` -Returns the product of `x` and `y`, `x * y`. Traps on overflow. +Returns the product of `x` and `y`, `x * y`. +Traps on overflow. + +Example: +```motoko include=import +ignore Nat16.mul(2, 3); // => 6 +(2 : Nat16) * (3 : Nat16) // => 6 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `*` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 1, Nat16.mul) // => 6 +``` ## Function `div` ``` motoko no-repl func div(x : Nat16, y : Nat16) : Nat16 ``` -Returns the division of `x by y`, `x / y`. +Returns the quotient of `x` divided by `y`, `x / y`. Traps when `y` is zero. +Example: +```motoko include=import +ignore Nat16.div(6, 2); // => 3 +(6 : Nat16) / (2 : Nat16) // => 3 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `/` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `/` +as a function value at the moment. + ## Function `rem` ``` motoko no-repl func rem(x : Nat16, y : Nat16) : Nat16 @@ -138,12 +402,35 @@ func rem(x : Nat16, y : Nat16) : Nat16 Returns the remainder of `x` divided by `y`, `x % y`. Traps when `y` is zero. +Example: +```motoko include=import +ignore Nat16.rem(6, 4); // => 2 +(6 : Nat16) % (4 : Nat16) // => 2 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `%` +as a function value at the moment. + ## Function `pow` ``` motoko no-repl func pow(x : Nat16, y : Nat16) : Nat16 ``` -Returns `x` to the power of `y`, `x ** y`. Traps on overflow. +Returns the power of `x` to `y`, `x ** y`. +Traps on overflow. + +Example: +```motoko include=import +ignore Nat16.pow(2, 3); // => 8 +(2 : Nat16) ** (3 : Nat16) // => 8 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**` +as a function value at the moment. ## Function `bitnot` ``` motoko no-repl @@ -152,6 +439,17 @@ func bitnot(x : Nat16) : Nat16 Returns the bitwise negation of `x`, `^x`. +Example: +```motoko include=import +ignore Nat16.bitnot(0); // => 65535 +^(0 : Nat16) // => 65535 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitand` ``` motoko no-repl func bitand(x : Nat16, y : Nat16) : Nat16 @@ -159,12 +457,29 @@ func bitand(x : Nat16, y : Nat16) : Nat16 Returns the bitwise and of `x` and `y`, `x & y`. +Example: +```motoko include=import +ignore Nat16.bitand(0, 1); // => 0 +(0 : Nat16) & (1 : Nat16) // => 0 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `&` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `&` +as a function value at the moment. + ## Function `bitor` ``` motoko no-repl func bitor(x : Nat16, y : Nat16) : Nat16 ``` -Returns the bitwise or of `x` and `y`, `x \| y`. +Returns the bitwise or of `x` and `y`, `x | y`. + +Example: +```motoko include=import +ignore Nat16.bitor(0, 1); // => 1 +(0 : Nat16) | (1 : Nat16) // => 1 +``` ## Function `bitxor` ``` motoko no-repl @@ -173,6 +488,12 @@ func bitxor(x : Nat16, y : Nat16) : Nat16 Returns the bitwise exclusive or of `x` and `y`, `x ^ y`. +Example: +```motoko include=import +ignore Nat16.bitxor(0, 1); // => 1 +(0 : Nat16) ^ (1 : Nat16) // => 1 +``` + ## Function `bitshiftLeft` ``` motoko no-repl func bitshiftLeft(x : Nat16, y : Nat16) : Nat16 @@ -180,6 +501,17 @@ func bitshiftLeft(x : Nat16, y : Nat16) : Nat16 Returns the bitwise shift left of `x` by `y`, `x << y`. +Example: +```motoko include=import +ignore Nat16.bitshiftLeft(1, 3); // => 8 +(1 : Nat16) << (3 : Nat16) // => 8 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<` +as a function value at the moment. + ## Function `bitshiftRight` ``` motoko no-repl func bitshiftRight(x : Nat16, y : Nat16) : Nat16 @@ -187,6 +519,17 @@ func bitshiftRight(x : Nat16, y : Nat16) : Nat16 Returns the bitwise shift right of `x` by `y`, `x >> y`. +Example: +```motoko include=import +ignore Nat16.bitshiftRight(8, 3); // => 1 +(8 : Nat16) >> (3 : Nat16) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>>` +as a function value at the moment. + ## Function `bitrotLeft` ``` motoko no-repl func bitrotLeft(x : Nat16, y : Nat16) : Nat16 @@ -194,6 +537,17 @@ func bitrotLeft(x : Nat16, y : Nat16) : Nat16 Returns the bitwise rotate left of `x` by `y`, `x <<> y`. +Example: +```motoko include=import +ignore Nat16.bitrotLeft(2, 1); // => 4 +(2 : Nat16) <<> (1 : Nat16) // => 4 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<<>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<>` +as a function value at the moment. + ## Function `bitrotRight` ``` motoko no-repl func bitrotRight(x : Nat16, y : Nat16) : Nat16 @@ -201,12 +555,29 @@ func bitrotRight(x : Nat16, y : Nat16) : Nat16 Returns the bitwise rotate right of `x` by `y`, `x <>> y`. +Example: +```motoko include=import +ignore Nat16.bitrotRight(1, 1); // => 32768 +(1 : Nat16) <>> (1 : Nat16) // => 32768 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<>>` +as a function value at the moment. + ## Function `bittest` ``` motoko no-repl func bittest(x : Nat16, p : Nat) : Bool ``` Returns the value of bit `p mod 16` in `x`, `(x & 2^(p mod 16)) == 2^(p mod 16)`. +This is equivalent to checking if the `p`-th bit is set in `x`, using 0 indexing. + +Example: +```motoko include=import +Nat16.bittest(5, 2); // => true +``` ## Function `bitset` ``` motoko no-repl @@ -215,6 +586,11 @@ func bitset(x : Nat16, p : Nat) : Nat16 Returns the value of setting bit `p mod 16` in `x` to `1`. +Example: +```motoko include=import +Nat16.bitset(0, 2); // => 4 +``` + ## Function `bitclear` ``` motoko no-repl func bitclear(x : Nat16, p : Nat) : Nat16 @@ -222,6 +598,11 @@ func bitclear(x : Nat16, p : Nat) : Nat16 Returns the value of clearing bit `p mod 16` in `x` to `0`. +Example: +```motoko include=import +Nat16.bitclear(5, 2); // => 1 +``` + ## Function `bitflip` ``` motoko no-repl func bitflip(x : Nat16, p : Nat) : Nat16 @@ -229,6 +610,11 @@ func bitflip(x : Nat16, p : Nat) : Nat16 Returns the value of flipping bit `p mod 16` in `x`. +Example: +```motoko include=import +Nat16.bitflip(5, 2); // => 1 +``` + ## Value `bitcountNonZero` ``` motoko no-repl let bitcountNonZero : (x : Nat16) -> Nat16 @@ -236,6 +622,11 @@ let bitcountNonZero : (x : Nat16) -> Nat16 Returns the count of non-zero bits in `x`. +Example: +```motoko include=import +Nat16.bitcountNonZero(5); // => 2 +``` + ## Value `bitcountLeadingZero` ``` motoko no-repl let bitcountLeadingZero : (x : Nat16) -> Nat16 @@ -243,6 +634,11 @@ let bitcountLeadingZero : (x : Nat16) -> Nat16 Returns the count of leading zero bits in `x`. +Example: +```motoko include=import +Nat16.bitcountLeadingZero(5); // => 13 +``` + ## Value `bitcountTrailingZero` ``` motoko no-repl let bitcountTrailingZero : (x : Nat16) -> Nat16 @@ -250,6 +646,11 @@ let bitcountTrailingZero : (x : Nat16) -> Nat16 Returns the count of trailing zero bits in `x`. +Example: +```motoko include=import +Nat16.bitcountTrailingZero(5); // => 0 +``` + ## Function `addWrap` ``` motoko no-repl func addWrap(x : Nat16, y : Nat16) : Nat16 @@ -257,6 +658,17 @@ func addWrap(x : Nat16, y : Nat16) : Nat16 Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow. +Example: +```motoko include=import +ignore Nat16.addWrap(65532, 5); // => 1 +(65532 : Nat16) +% (5 : Nat16) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `+%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+%` +as a function value at the moment. + ## Function `subWrap` ``` motoko no-repl func subWrap(x : Nat16, y : Nat16) : Nat16 @@ -264,6 +676,17 @@ func subWrap(x : Nat16, y : Nat16) : Nat16 Returns the difference of `x` and `y`, `x -% y`. Wraps on underflow. +Example: +```motoko include=import +ignore Nat16.subWrap(1, 2); // => 65535 +(1 : Nat16) -% (2 : Nat16) // => 65535 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `-%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-%` +as a function value at the moment. + ## Function `mulWrap` ``` motoko no-repl func mulWrap(x : Nat16, y : Nat16) : Nat16 @@ -271,9 +694,31 @@ func mulWrap(x : Nat16, y : Nat16) : Nat16 Returns the product of `x` and `y`, `x *% y`. Wraps on overflow. +Example: +```motoko include=import +ignore Nat16.mulWrap(655, 101); // => 619 +(655 : Nat16) *% (101 : Nat16) // => 619 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `*%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*%` +as a function value at the moment. + ## Function `powWrap` ``` motoko no-repl func powWrap(x : Nat16, y : Nat16) : Nat16 ``` Returns `x` to the power of `y`, `x **% y`. Wraps on overflow. + +Example: +```motoko include=import +ignore Nat16.powWrap(2, 16); // => 0 +(2 : Nat16) **% (16 : Nat16) // => 0 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**%` +as a function value at the moment. diff --git a/doc/md/base/Nat32.md b/doc/md/base/Nat32.md index 17efaee29e6..c080931ec35 100644 --- a/doc/md/base/Nat32.md +++ b/doc/md/base/Nat32.md @@ -1,7 +1,12 @@ # Nat32 -32-bit unsigned integers with checked arithmetic +Provides utility functions on 32-bit unsigned integers. -Most operations are available as built-in operators (e.g. `1 + 1`). +Note that most operations are available as built-in operators (e.g. `1 + 1`). + +Import from the base library to use this module. +```motoko name=import +import Nat32 "mo:base/Nat32"; +``` ## Type `Nat32` ``` motoko no-repl @@ -10,33 +15,122 @@ type Nat32 = Prim.Types.Nat32 32-bit natural numbers. +## Value `maximumValue` +``` motoko no-repl +let maximumValue : Nat32 +``` + +Maximum 32-bit natural number. `2 ** 32 - 1`. + +Example: +```motoko include=import +Nat32.maximumValue; // => 4294967295 : Nat32 +``` + ## Value `toNat` ``` motoko no-repl let toNat : Nat32 -> Nat ``` -Conversion. +Converts a 32-bit unsigned integer to an unsigned integer with infinite precision. + +Example: +```motoko include=import +Nat32.toNat(123); // => 123 : Nat +``` ## Value `fromNat` ``` motoko no-repl let fromNat : Nat -> Nat32 ``` -Conversion. Traps on overflow/underflow. +Converts an unsigned integer with infinite precision to a 32-bit unsigned integer. + +Traps on overflow. + +Example: +```motoko include=import +Nat32.fromNat(123); // => 123 : Nat32 +``` + +## Function `fromNat16` +``` motoko no-repl +func fromNat16(x : Nat16) : Nat32 +``` + +Converts a 16-bit unsigned integer to a 32-bit unsigned integer. + +Example: +```motoko include=import +Nat32.fromNat16(123); // => 123 : Nat32 +``` + +## Function `toNat16` +``` motoko no-repl +func toNat16(x : Nat32) : Nat16 +``` + +Converts a 32-bit unsigned integer to a 16-bit unsigned integer. + +Traps on overflow. + +Example: +```motoko include=import +Nat32.toNat16(123); // => 123 : Nat16 +``` + +## Function `fromNat64` +``` motoko no-repl +func fromNat64(x : Nat64) : Nat32 +``` + +Converts a 64-bit unsigned integer to a 32-bit unsigned integer. + +Traps on overflow. + +Example: +```motoko include=import +Nat32.fromNat64(123); // => 123 : Nat32 +``` + +## Function `toNat64` +``` motoko no-repl +func toNat64(x : Nat32) : Nat64 +``` + +Converts a 32-bit unsigned integer to a 64-bit unsigned integer. + +Example: +```motoko include=import +Nat32.toNat64(123); // => 123 : Nat64 +``` ## Value `fromIntWrap` ``` motoko no-repl let fromIntWrap : Int -> Nat32 ``` -Conversion. Wraps on overflow/underflow. +Converts a signed integer with infinite precision to a 32-bit unsigned integer. + +Traps on overflow/underflow. + +Example: +```motoko include=import +Nat32.fromIntWrap(123); // => 123 : Nat32 +``` ## Function `toText` ``` motoko no-repl func toText(x : Nat32) : Text ``` -Returns the Text representation of `x`. +Converts `x` to its textual representation. Textual representation _do not_ +contain underscores to represent commas. + +Example: +```motoko include=import +Nat32.toText(1234); // => "1234" : Text +``` ## Function `min` ``` motoko no-repl @@ -45,6 +139,11 @@ func min(x : Nat32, y : Nat32) : Nat32 Returns the minimum of `x` and `y`. +Example: +```motoko include=import +Nat32.min(123, 456); // => 123 : Nat32 +``` + ## Function `max` ``` motoko no-repl func max(x : Nat32, y : Nat32) : Nat32 @@ -52,75 +151,229 @@ func max(x : Nat32, y : Nat32) : Nat32 Returns the maximum of `x` and `y`. +Example: +```motoko include=import +Nat32.max(123, 456); // => 456 : Nat32 +``` + ## Function `equal` ``` motoko no-repl func equal(x : Nat32, y : Nat32) : Bool ``` -Returns `x == y`. +Equality function for Nat32 types. +This is equivalent to `x == y`. + +Example: +```motoko include=import +ignore Nat32.equal(1, 1); // => true +(1 : Nat32) == (1 : Nat32) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `==` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `==` +as a function value at the moment. + +Example: +```motoko include=import +import Buffer "mo:base/Buffer"; + +let buffer1 = Buffer.Buffer(3); +let buffer2 = Buffer.Buffer(3); +Buffer.equal(buffer1, buffer2, Nat32.equal) // => true +``` ## Function `notEqual` ``` motoko no-repl func notEqual(x : Nat32, y : Nat32) : Bool ``` -Returns `x != y`. +Inequality function for Nat32 types. +This is equivalent to `x != y`. + +Example: +```motoko include=import +ignore Nat32.notEqual(1, 2); // => true +(1 : Nat32) != (2 : Nat32) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `!=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `!=` +as a function value at the moment. ## Function `less` ``` motoko no-repl func less(x : Nat32, y : Nat32) : Bool ``` -Returns `x < y`. +"Less than" function for Nat32 types. +This is equivalent to `x < y`. + +Example: +```motoko include=import +ignore Nat32.less(1, 2); // => true +(1 : Nat32) < (2 : Nat32) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<` +as a function value at the moment. ## Function `lessOrEqual` ``` motoko no-repl func lessOrEqual(x : Nat32, y : Nat32) : Bool ``` -Returns `x <= y`. +"Less than or equal" function for Nat32 types. +This is equivalent to `x <= y`. + +Example: +```motoko include=import +ignore Nat32.lessOrEqual(1, 2); // => true +(1 : Nat32) <= (2 : Nat32) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<=` +as a function value at the moment. ## Function `greater` ``` motoko no-repl func greater(x : Nat32, y : Nat32) : Bool ``` -Returns `x > y`. +"Greater than" function for Nat32 types. +This is equivalent to `x > y`. + +Example: +```motoko include=import +ignore Nat32.greater(2, 1); // => true +(2 : Nat32) > (1 : Nat32) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>` +as a function value at the moment. ## Function `greaterOrEqual` ``` motoko no-repl func greaterOrEqual(x : Nat32, y : Nat32) : Bool ``` -Returns `x >= y`. +"Greater than or equal" function for Nat32 types. +This is equivalent to `x >= y`. + +Example: +```motoko include=import +ignore Nat32.greaterOrEqual(2, 1); // => true +(2 : Nat32) >= (1 : Nat32) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>=` +as a function value at the moment. ## Function `compare` ``` motoko no-repl func compare(x : Nat32, y : Nat32) : {#less; #equal; #greater} ``` -Returns the order of `x` and `y`. +General purpose comparison function for `Nat32`. Returns the `Order` ( +either `#less`, `#equal`, or `#greater`) of comparing `x` with `y`. + +Example: +```motoko include=import +Nat32.compare(2, 3) // => #less +``` + +This function can be used as value for a high order function, such as a sort function. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.sort([2, 3, 1] : [Nat32], Nat32.compare) // => [1, 2, 3] +``` ## Function `add` ``` motoko no-repl func add(x : Nat32, y : Nat32) : Nat32 ``` -Returns the sum of `x` and `y`, `x + y`. Traps on overflow. +Returns the sum of `x` and `y`, `x + y`. +Traps on overflow. + +Example: +```motoko include=import +ignore Nat32.add(1, 2); // => 3 +(1 : Nat32) + (2 : Nat32) // => 3 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `+` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 0, Nat32.add) // => 6 +``` ## Function `sub` ``` motoko no-repl func sub(x : Nat32, y : Nat32) : Nat32 ``` -Returns the difference of `x` and `y`, `x - y`. Traps on underflow. +Returns the difference of `x` and `y`, `x - y`. +Traps on underflow. + +Example: +```motoko include=import +ignore Nat32.sub(2, 1); // => 1 +(2 : Nat32) - (1 : Nat32) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 20, Nat32.sub) // => 14 +``` ## Function `mul` ``` motoko no-repl func mul(x : Nat32, y : Nat32) : Nat32 ``` -Returns the product of `x` and `y`, `x * y`. Traps on overflow. +Returns the product of `x` and `y`, `x * y`. +Traps on overflow. + +Example: +```motoko include=import +ignore Nat32.mul(2, 3); // => 6 +(2 : Nat32) * (3 : Nat32) // => 6 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `*` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 1, Nat32.mul) // => 6 +``` ## Function `div` ``` motoko no-repl @@ -130,6 +383,17 @@ func div(x : Nat32, y : Nat32) : Nat32 Returns the division of `x by y`, `x / y`. Traps when `y` is zero. +Example: +```motoko include=import +ignore Nat32.div(6, 2); // => 3 +(6 : Nat32) / (2 : Nat32) // => 3 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `/` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `/` +as a function value at the moment. + ## Function `rem` ``` motoko no-repl func rem(x : Nat32, y : Nat32) : Nat32 @@ -138,6 +402,17 @@ func rem(x : Nat32, y : Nat32) : Nat32 Returns the remainder of `x` divided by `y`, `x % y`. Traps when `y` is zero. +Example: +```motoko include=import +ignore Nat32.rem(6, 4); // => 2 +(6 : Nat32) % (4 : Nat32) // => 2 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `%` +as a function value at the moment. + ## Function `pow` ``` motoko no-repl func pow(x : Nat32, y : Nat32) : Nat32 @@ -145,6 +420,17 @@ func pow(x : Nat32, y : Nat32) : Nat32 Returns `x` to the power of `y`, `x ** y`. Traps on overflow. +Example: +```motoko include=import +ignore Nat32.pow(2, 3); // => 8 +(2 : Nat32) ** (3 : Nat32) // => 8 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**` +as a function value at the moment. + ## Function `bitnot` ``` motoko no-repl func bitnot(x : Nat32) : Nat32 @@ -152,6 +438,17 @@ func bitnot(x : Nat32) : Nat32 Returns the bitwise negation of `x`, `^x`. +Example: +```motoko include=import +ignore Nat32.bitnot(0) // => 4294967295 +^(0 : Nat32) // => 4294967295 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitand` ``` motoko no-repl func bitand(x : Nat32, y : Nat32) : Nat32 @@ -159,12 +456,34 @@ func bitand(x : Nat32, y : Nat32) : Nat32 Returns the bitwise and of `x` and `y`, `x & y`. +Example: +```motoko include=import +ignore Nat32.bitand(1, 3); // => 1 +(1 : Nat32) & (3 : Nat32) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `&` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `&` +as a function value at the moment. + ## Function `bitor` ``` motoko no-repl func bitor(x : Nat32, y : Nat32) : Nat32 ``` -Returns the bitwise or of `x` and `y`, `x \| y`. +Returns the bitwise or of `x` and `y`, `x | y`. + +Example: +```motoko include=import +ignore Nat32.bitor(1, 3); // => 3 +(1 : Nat32) | (3 : Nat32) // => 3 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `|` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `|` +as a function value at the moment. ## Function `bitxor` ``` motoko no-repl @@ -173,6 +492,17 @@ func bitxor(x : Nat32, y : Nat32) : Nat32 Returns the bitwise exclusive or of `x` and `y`, `x ^ y`. +Example: +```motoko include=import +ignore Nat32.bitxor(1, 3); // => 2 +(1 : Nat32) ^ (3 : Nat32) // => 2 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitshiftLeft` ``` motoko no-repl func bitshiftLeft(x : Nat32, y : Nat32) : Nat32 @@ -180,6 +510,17 @@ func bitshiftLeft(x : Nat32, y : Nat32) : Nat32 Returns the bitwise shift left of `x` by `y`, `x << y`. +Example: +```motoko include=import +ignore Nat32.bitshiftLeft(1, 3); // => 8 +(1 : Nat32) << (3 : Nat32) // => 8 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<` +as a function value at the moment. + ## Function `bitshiftRight` ``` motoko no-repl func bitshiftRight(x : Nat32, y : Nat32) : Nat32 @@ -187,6 +528,17 @@ func bitshiftRight(x : Nat32, y : Nat32) : Nat32 Returns the bitwise shift right of `x` by `y`, `x >> y`. +Example: +```motoko include=import +ignore Nat32.bitshiftRight(8, 3); // => 1 +(8 : Nat32) >> (3 : Nat32) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>>` +as a function value at the moment. + ## Function `bitrotLeft` ``` motoko no-repl func bitrotLeft(x : Nat32, y : Nat32) : Nat32 @@ -194,6 +546,17 @@ func bitrotLeft(x : Nat32, y : Nat32) : Nat32 Returns the bitwise rotate left of `x` by `y`, `x <<> y`. +Example: +```motoko include=import +ignore Nat32.bitrotLeft(1, 3); // => 8 +(1 : Nat32) <<> (3 : Nat32) // => 8 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<<>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<>` +as a function value at the moment. + ## Function `bitrotRight` ``` motoko no-repl func bitrotRight(x : Nat32, y : Nat32) : Nat32 @@ -201,12 +564,29 @@ func bitrotRight(x : Nat32, y : Nat32) : Nat32 Returns the bitwise rotate right of `x` by `y`, `x <>> y`. +Example: +```motoko include=import +ignore Nat32.bitrotRight(1, 1); // => 2147483648 +(1 : Nat32) <>> (1 : Nat32) // => 2147483648 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<>>` +as a function value at the moment. + ## Function `bittest` ``` motoko no-repl func bittest(x : Nat32, p : Nat) : Bool ``` Returns the value of bit `p mod 32` in `x`, `(x & 2^(p mod 32)) == 2^(p mod 32)`. +This is equivalent to checking if the `p`-th bit is set in `x`, using 0 indexing. + +Example: +```motoko include=import +Nat32.bittest(5, 2); // => true +``` ## Function `bitset` ``` motoko no-repl @@ -215,6 +595,11 @@ func bitset(x : Nat32, p : Nat) : Nat32 Returns the value of setting bit `p mod 32` in `x` to `1`. +Example: +```motoko include=import +Nat32.bitset(5, 1); // => 7 +``` + ## Function `bitclear` ``` motoko no-repl func bitclear(x : Nat32, p : Nat) : Nat32 @@ -222,6 +607,11 @@ func bitclear(x : Nat32, p : Nat) : Nat32 Returns the value of clearing bit `p mod 32` in `x` to `0`. +Example: +```motoko include=import +Nat32.bitclear(5, 2); // => 1 +``` + ## Function `bitflip` ``` motoko no-repl func bitflip(x : Nat32, p : Nat) : Nat32 @@ -229,6 +619,11 @@ func bitflip(x : Nat32, p : Nat) : Nat32 Returns the value of flipping bit `p mod 32` in `x`. +Example: +```motoko include=import +Nat32.bitflip(5, 2); // => 1 +``` + ## Value `bitcountNonZero` ``` motoko no-repl let bitcountNonZero : (x : Nat32) -> Nat32 @@ -236,6 +631,11 @@ let bitcountNonZero : (x : Nat32) -> Nat32 Returns the count of non-zero bits in `x`. +Example: +```motoko include=import +Nat32.bitcountNonZero(5); // => 2 +``` + ## Value `bitcountLeadingZero` ``` motoko no-repl let bitcountLeadingZero : (x : Nat32) -> Nat32 @@ -243,6 +643,11 @@ let bitcountLeadingZero : (x : Nat32) -> Nat32 Returns the count of leading zero bits in `x`. +Example: +```motoko include=import +Nat32.bitcountLeadingZero(5); // => 29 +``` + ## Value `bitcountTrailingZero` ``` motoko no-repl let bitcountTrailingZero : (x : Nat32) -> Nat32 @@ -250,6 +655,11 @@ let bitcountTrailingZero : (x : Nat32) -> Nat32 Returns the count of trailing zero bits in `x`. +Example: +```motoko include=import +Nat32.bitcountTrailingZero(16); // => 4 +``` + ## Function `addWrap` ``` motoko no-repl func addWrap(x : Nat32, y : Nat32) : Nat32 @@ -257,6 +667,17 @@ func addWrap(x : Nat32, y : Nat32) : Nat32 Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow. +Example: +```motoko include=import +ignore Nat32.addWrap(4294967295, 1); // => 0 +(4294967295 : Nat32) +% (1 : Nat32) // => 0 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `+%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+%` +as a function value at the moment. + ## Function `subWrap` ``` motoko no-repl func subWrap(x : Nat32, y : Nat32) : Nat32 @@ -264,6 +685,17 @@ func subWrap(x : Nat32, y : Nat32) : Nat32 Returns the difference of `x` and `y`, `x -% y`. Wraps on underflow. +Example: +```motoko include=import +ignore Nat32.subWrap(0, 1); // => 4294967295 +(0 : Nat32) -% (1 : Nat32) // => 4294967295 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `-%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-%` +as a function value at the moment. + ## Function `mulWrap` ``` motoko no-repl func mulWrap(x : Nat32, y : Nat32) : Nat32 @@ -271,9 +703,31 @@ func mulWrap(x : Nat32, y : Nat32) : Nat32 Returns the product of `x` and `y`, `x *% y`. Wraps on overflow. +Example: +```motoko include=import +ignore Nat32.mulWrap(2147483648, 2); // => 0 +(2147483648 : Nat32) *% (2 : Nat32) // => 0 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `*%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*%` +as a function value at the moment. + ## Function `powWrap` ``` motoko no-repl func powWrap(x : Nat32, y : Nat32) : Nat32 ``` Returns `x` to the power of `y`, `x **% y`. Wraps on overflow. + +Example: +```motoko include=import +ignore Nat32.powWrap(2, 32); // => 0 +(2 : Nat32) **% (32 : Nat32) // => 0 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**%` +as a function value at the moment. diff --git a/doc/md/base/Nat64.md b/doc/md/base/Nat64.md index 8ad9048790b..315202d0816 100644 --- a/doc/md/base/Nat64.md +++ b/doc/md/base/Nat64.md @@ -1,7 +1,12 @@ # Nat64 -64-bit unsigned integers with checked arithmetic +Provides utility functions on 64-bit unsigned integers. -Most operations are available as built-in operators (e.g. `1 + 1`). +Note that most operations are available as built-in operators (e.g. `1 + 1`). + +Import from the base library to use this module. +```motoko name=import +import Nat64 "mo:base/Nat64"; +``` ## Type `Nat64` ``` motoko no-repl @@ -10,33 +15,96 @@ type Nat64 = Prim.Types.Nat64 64-bit natural numbers. +## Value `maximumValue` +``` motoko no-repl +let maximumValue : Nat64 +``` + +Maximum 64-bit natural number. `2 ** 64 - 1`. + +Example: +```motoko include=import +Nat64.maximumValue; // => 18446744073709551615 : Nat64 +``` + ## Value `toNat` ``` motoko no-repl let toNat : Nat64 -> Nat ``` -Conversion. +Converts a 64-bit unsigned integer to an unsigned integer with infinite precision. + +Example: +```motoko include=import +Nat64.toNat(123); // => 123 : Nat +``` ## Value `fromNat` ``` motoko no-repl let fromNat : Nat -> Nat64 ``` -Conversion. Traps on overflow/underflow. +Converts an unsigned integer with infinite precision to a 64-bit unsigned integer. + +Traps on overflow. + +Example: +```motoko include=import +Nat64.fromNat(123); // => 123 : Nat64 +``` + +## Function `fromNat32` +``` motoko no-repl +func fromNat32(x : Nat32) : Nat64 +``` + +Converts a 32-bit unsigned integer to a 64-bit unsigned integer. + +Example: +```motoko include=import +Nat64.fromNat32(123); // => 123 : Nat64 +``` + +## Function `toNat32` +``` motoko no-repl +func toNat32(x : Nat64) : Nat32 +``` + +Converts a 64-bit unsigned integer to a 32-bit unsigned integer. + +Traps on overflow. + +Example: +```motoko include=import +Nat64.toNat32(123); // => 123 : Nat32 +``` ## Value `fromIntWrap` ``` motoko no-repl let fromIntWrap : Int -> Nat64 ``` -Conversion. Wraps on overflow/underflow. +Converts a signed integer with infinite precision to a 64-bit unsigned integer. + +Traps on overflow/underflow. + +Example: +```motoko include=import +Nat64.fromIntWrap(123); // => 123 : Nat64 +``` ## Function `toText` ``` motoko no-repl func toText(x : Nat64) : Text ``` -Returns the Text representation of `x`. +Converts `x` to its textual representation. Textual representation _do not_ +contain underscores to represent commas. + +Example: +```motoko include=import +Nat64.toText(1234); // => "1234" : Text +``` ## Function `min` ``` motoko no-repl @@ -45,6 +113,11 @@ func min(x : Nat64, y : Nat64) : Nat64 Returns the minimum of `x` and `y`. +Example: +```motoko include=import +Nat64.min(123, 456); // => 123 : Nat64 +``` + ## Function `max` ``` motoko no-repl func max(x : Nat64, y : Nat64) : Nat64 @@ -52,84 +125,249 @@ func max(x : Nat64, y : Nat64) : Nat64 Returns the maximum of `x` and `y`. +Example: +```motoko include=import +Nat64.max(123, 456); // => 456 : Nat64 +``` + ## Function `equal` ``` motoko no-repl func equal(x : Nat64, y : Nat64) : Bool ``` -Returns `x == y`. +Equality function for Nat64 types. +This is equivalent to `x == y`. + +Example: +```motoko include=import +ignore Nat64.equal(1, 1); // => true +(1 : Nat64) == (1 : Nat64) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `==` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `==` +as a function value at the moment. + +Example: +```motoko include=import +import Buffer "mo:base/Buffer"; + +let buffer1 = Buffer.Buffer(3); +let buffer2 = Buffer.Buffer(3); +Buffer.equal(buffer1, buffer2, Nat64.equal) // => true +``` ## Function `notEqual` ``` motoko no-repl func notEqual(x : Nat64, y : Nat64) : Bool ``` -Returns `x != y`. +Inequality function for Nat64 types. +This is equivalent to `x != y`. + +Example: +```motoko include=import +ignore Nat64.notEqual(1, 2); // => true +(1 : Nat64) != (2 : Nat64) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `!=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `!=` +as a function value at the moment. ## Function `less` ``` motoko no-repl func less(x : Nat64, y : Nat64) : Bool ``` -Returns `x < y`. +"Less than" function for Nat64 types. +This is equivalent to `x < y`. + +Example: +```motoko include=import +ignore Nat64.less(1, 2); // => true +(1 : Nat64) < (2 : Nat64) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<` +as a function value at the moment. ## Function `lessOrEqual` ``` motoko no-repl func lessOrEqual(x : Nat64, y : Nat64) : Bool ``` -Returns `x <= y`. +"Less than or equal" function for Nat64 types. +This is equivalent to `x <= y`. + +Example: +```motoko include=import +ignore Nat64.lessOrEqual(1, 2); // => true +(1 : Nat64) <= (2 : Nat64) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<=` +as a function value at the moment. ## Function `greater` ``` motoko no-repl func greater(x : Nat64, y : Nat64) : Bool ``` -Returns `x > y`. +"Greater than" function for Nat64 types. +This is equivalent to `x > y`. + +Example: +```motoko include=import +ignore Nat64.greater(2, 1); // => true +(2 : Nat64) > (1 : Nat64) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>` +as a function value at the moment. ## Function `greaterOrEqual` ``` motoko no-repl func greaterOrEqual(x : Nat64, y : Nat64) : Bool ``` -Returns `x >= y`. +"Greater than or equal" function for Nat64 types. +This is equivalent to `x >= y`. + +Example: +```motoko include=import +ignore Nat64.greaterOrEqual(2, 1); // => true +(2 : Nat64) >= (1 : Nat64) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>=` +as a function value at the moment. ## Function `compare` ``` motoko no-repl func compare(x : Nat64, y : Nat64) : {#less; #equal; #greater} ``` -Returns the order of `x` and `y`. +General purpose comparison function for `Nat64`. Returns the `Order` ( +either `#less`, `#equal`, or `#greater`) of comparing `x` with `y`. + +Example: +```motoko include=import +Nat64.compare(2, 3) // => #less +``` + +This function can be used as value for a high order function, such as a sort function. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.sort([2, 3, 1] : [Nat64], Nat64.compare) // => [1, 2, 3] +``` ## Function `add` ``` motoko no-repl func add(x : Nat64, y : Nat64) : Nat64 ``` -Returns the sum of `x` and `y`, `x + y`. Traps on overflow. +Returns the sum of `x` and `y`, `x + y`. +Traps on overflow. + +Example: +```motoko include=import +ignore Nat64.add(1, 2); // => 3 +(1 : Nat64) + (2 : Nat64) // => 3 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `+` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 0, Nat64.add) // => 6 +``` ## Function `sub` ``` motoko no-repl func sub(x : Nat64, y : Nat64) : Nat64 ``` -Returns the difference of `x` and `y`, `x - y`. Traps on underflow. +Returns the difference of `x` and `y`, `x - y`. +Traps on underflow. + +Example: +```motoko include=import +ignore Nat64.sub(3, 1); // => 2 +(3 : Nat64) - (1 : Nat64) // => 2 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 10, Nat64.sub) // => 4 +``` ## Function `mul` ``` motoko no-repl func mul(x : Nat64, y : Nat64) : Nat64 ``` -Returns the product of `x` and `y`, `x * y`. Traps on overflow. +Returns the product of `x` and `y`, `x * y`. +Traps on overflow. + +Example: +```motoko include=import +ignore Nat64.mul(2, 3); // => 6 +(2 : Nat64) * (3 : Nat64) // => 6 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `*` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 1, Nat64.mul) // => 6 +``` ## Function `div` ``` motoko no-repl func div(x : Nat64, y : Nat64) : Nat64 ``` -Returns the division of `x by y`, `x / y`. +Returns the quotient of `x` divided by `y`, `x / y`. Traps when `y` is zero. +Example: +```motoko include=import +ignore Nat64.div(6, 2); // => 3 +(6 : Nat64) / (2 : Nat64) // => 3 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `/` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `/` +as a function value at the moment. + ## Function `rem` ``` motoko no-repl func rem(x : Nat64, y : Nat64) : Nat64 @@ -138,6 +376,17 @@ func rem(x : Nat64, y : Nat64) : Nat64 Returns the remainder of `x` divided by `y`, `x % y`. Traps when `y` is zero. +Example: +```motoko include=import +ignore Nat64.rem(6, 4); // => 2 +(6 : Nat64) % (4 : Nat64) // => 2 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `%` +as a function value at the moment. + ## Function `pow` ``` motoko no-repl func pow(x : Nat64, y : Nat64) : Nat64 @@ -145,6 +394,17 @@ func pow(x : Nat64, y : Nat64) : Nat64 Returns `x` to the power of `y`, `x ** y`. Traps on overflow. +Example: +```motoko include=import +ignore Nat64.pow(2, 3); // => 8 +(2 : Nat64) ** (3 : Nat64) // => 8 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**` +as a function value at the moment. + ## Function `bitnot` ``` motoko no-repl func bitnot(x : Nat64) : Nat64 @@ -152,6 +412,17 @@ func bitnot(x : Nat64) : Nat64 Returns the bitwise negation of `x`, `^x`. +Example: +```motoko include=import +ignore Nat64.bitnot(0); // => 18446744073709551615 +^(0 : Nat64) // => 18446744073709551615 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitand` ``` motoko no-repl func bitand(x : Nat64, y : Nat64) : Nat64 @@ -159,12 +430,34 @@ func bitand(x : Nat64, y : Nat64) : Nat64 Returns the bitwise and of `x` and `y`, `x & y`. +Example: +```motoko include=import +ignore Nat64.bitand(1, 3); // => 1 +(1 : Nat64) & (3 : Nat64) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `&` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `&` +as a function value at the moment. + ## Function `bitor` ``` motoko no-repl func bitor(x : Nat64, y : Nat64) : Nat64 ``` -Returns the bitwise or of `x` and `y`, `x \| y`. +Returns the bitwise or of `x` and `y`, `x | y`. + +Example: +```motoko include=import +ignore Nat64.bitor(1, 3); // => 3 +(1 : Nat64) | (3 : Nat64) // => 3 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `|` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `|` +as a function value at the moment. ## Function `bitxor` ``` motoko no-repl @@ -173,6 +466,17 @@ func bitxor(x : Nat64, y : Nat64) : Nat64 Returns the bitwise exclusive or of `x` and `y`, `x ^ y`. +Example: +```motoko include=import +ignore Nat64.bitxor(1, 3); // => 2 +(1 : Nat64) ^ (3 : Nat64) // => 2 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitshiftLeft` ``` motoko no-repl func bitshiftLeft(x : Nat64, y : Nat64) : Nat64 @@ -180,6 +484,17 @@ func bitshiftLeft(x : Nat64, y : Nat64) : Nat64 Returns the bitwise shift left of `x` by `y`, `x << y`. +Example: +```motoko include=import +ignore Nat64.bitshiftLeft(1, 3); // => 8 +(1 : Nat64) << (3 : Nat64) // => 8 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<` +as a function value at the moment. + ## Function `bitshiftRight` ``` motoko no-repl func bitshiftRight(x : Nat64, y : Nat64) : Nat64 @@ -187,6 +502,17 @@ func bitshiftRight(x : Nat64, y : Nat64) : Nat64 Returns the bitwise shift right of `x` by `y`, `x >> y`. +Example: +```motoko include=import +ignore Nat64.bitshiftRight(8, 3); // => 1 +(8 : Nat64) >> (3 : Nat64) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>>` +as a function value at the moment. + ## Function `bitrotLeft` ``` motoko no-repl func bitrotLeft(x : Nat64, y : Nat64) : Nat64 @@ -194,6 +520,17 @@ func bitrotLeft(x : Nat64, y : Nat64) : Nat64 Returns the bitwise rotate left of `x` by `y`, `x <<> y`. +Example: +```motoko include=import +ignore Nat64.bitrotLeft(1, 3); // => 8 +(1 : Nat64) <<> (3 : Nat64) // => 8 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<<>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<>` +as a function value at the moment. + ## Function `bitrotRight` ``` motoko no-repl func bitrotRight(x : Nat64, y : Nat64) : Nat64 @@ -201,12 +538,29 @@ func bitrotRight(x : Nat64, y : Nat64) : Nat64 Returns the bitwise rotate right of `x` by `y`, `x <>> y`. +Example: +```motoko include=import +ignore Nat64.bitrotRight(8, 3); // => 1 +(8 : Nat64) <>> (3 : Nat64) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<>>` +as a function value at the moment. + ## Function `bittest` ``` motoko no-repl func bittest(x : Nat64, p : Nat) : Bool ``` Returns the value of bit `p mod 64` in `x`, `(x & 2^(p mod 64)) == 2^(p mod 64)`. +This is equivalent to checking if the `p`-th bit is set in `x`, using 0 indexing. + +Example: +```motoko include=import +Nat64.bittest(5, 2); // => true +``` ## Function `bitset` ``` motoko no-repl @@ -215,6 +569,11 @@ func bitset(x : Nat64, p : Nat) : Nat64 Returns the value of setting bit `p mod 64` in `x` to `1`. +Example: +```motoko include=import +Nat64.bitset(5, 1); // => 7 +``` + ## Function `bitclear` ``` motoko no-repl func bitclear(x : Nat64, p : Nat) : Nat64 @@ -222,6 +581,11 @@ func bitclear(x : Nat64, p : Nat) : Nat64 Returns the value of clearing bit `p mod 64` in `x` to `0`. +Example: +```motoko include=import +Nat64.bitclear(5, 2); // => 1 +``` + ## Function `bitflip` ``` motoko no-repl func bitflip(x : Nat64, p : Nat) : Nat64 @@ -229,6 +593,11 @@ func bitflip(x : Nat64, p : Nat) : Nat64 Returns the value of flipping bit `p mod 64` in `x`. +Example: +```motoko include=import +Nat64.bitflip(5, 2); // => 1 +``` + ## Value `bitcountNonZero` ``` motoko no-repl let bitcountNonZero : (x : Nat64) -> Nat64 @@ -236,6 +605,11 @@ let bitcountNonZero : (x : Nat64) -> Nat64 Returns the count of non-zero bits in `x`. +Example: +```motoko include=import +Nat64.bitcountNonZero(5); // => 2 +``` + ## Value `bitcountLeadingZero` ``` motoko no-repl let bitcountLeadingZero : (x : Nat64) -> Nat64 @@ -243,6 +617,11 @@ let bitcountLeadingZero : (x : Nat64) -> Nat64 Returns the count of leading zero bits in `x`. +Example: +```motoko include=import +Nat64.bitcountLeadingZero(5); // => 61 +``` + ## Value `bitcountTrailingZero` ``` motoko no-repl let bitcountTrailingZero : (x : Nat64) -> Nat64 @@ -250,6 +629,11 @@ let bitcountTrailingZero : (x : Nat64) -> Nat64 Returns the count of trailing zero bits in `x`. +Example: +```motoko include=import +Nat64.bitcountTrailingZero(16); // => 4 +``` + ## Function `addWrap` ``` motoko no-repl func addWrap(x : Nat64, y : Nat64) : Nat64 @@ -257,6 +641,17 @@ func addWrap(x : Nat64, y : Nat64) : Nat64 Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow. +Example: +```motoko include=import +ignore Nat64.addWrap(Nat64.maximumValue, 1); // => 0 +Nat64.maximumValue +% (1 : Nat64) // => 0 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `+%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+%` +as a function value at the moment. + ## Function `subWrap` ``` motoko no-repl func subWrap(x : Nat64, y : Nat64) : Nat64 @@ -264,6 +659,17 @@ func subWrap(x : Nat64, y : Nat64) : Nat64 Returns the difference of `x` and `y`, `x -% y`. Wraps on underflow. +Example: +```motoko include=import +ignore Nat64.subWrap(0, 1); // => 18446744073709551615 +(0 : Nat64) -% (1 : Nat64) // => 18446744073709551615 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `-%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-%` +as a function value at the moment. + ## Function `mulWrap` ``` motoko no-repl func mulWrap(x : Nat64, y : Nat64) : Nat64 @@ -271,9 +677,31 @@ func mulWrap(x : Nat64, y : Nat64) : Nat64 Returns the product of `x` and `y`, `x *% y`. Wraps on overflow. +Example: +```motoko include=import +ignore Nat64.mulWrap(4294967296, 4294967296); // => 0 +(4294967296 : Nat64) *% (4294967296 : Nat64) // => 0 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `*%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*%` +as a function value at the moment. + ## Function `powWrap` ``` motoko no-repl func powWrap(x : Nat64, y : Nat64) : Nat64 ``` Returns `x` to the power of `y`, `x **% y`. Wraps on overflow. + +Example: +```motoko include=import +ignore Nat64.powWrap(2, 64); // => 0 +(2 : Nat64) **% (64 : Nat64) // => 0 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**%` +as a function value at the moment. diff --git a/doc/md/base/Nat8.md b/doc/md/base/Nat8.md index 6f257989317..0c23c20f1c1 100644 --- a/doc/md/base/Nat8.md +++ b/doc/md/base/Nat8.md @@ -1,7 +1,12 @@ # Nat8 -8-bit unsigned integers with checked arithmetic +Provides utility functions on 8-bit unsigned integers. -Most operations are available as built-in operators (e.g. `1 + 1`). +Note that most operations are available as built-in operators (e.g. `1 + 1`). + +Import from the base library to use this module. +```motoko name=import +import Nat8 "mo:base/Nat8"; +``` ## Type `Nat8` ``` motoko no-repl @@ -10,33 +15,95 @@ type Nat8 = Prim.Types.Nat8 8-bit natural numbers. +## Value `maximumValue` +``` motoko no-repl +let maximumValue : Nat8 +``` + +Maximum 8-bit natural number. `2 ** 8 - 1`. + +Example: +```motoko include=import +Nat8.maximumValue; // => 255 : Nat8 +``` + ## Value `toNat` ``` motoko no-repl let toNat : Nat8 -> Nat ``` -Conversion. +Converts an 8-bit unsigned integer to an unsigned integer with infinite precision. + +Example: +```motoko include=import +Nat8.toNat(123); // => 123 : Nat +``` ## Value `fromNat` ``` motoko no-repl let fromNat : Nat -> Nat8 ``` -Conversion. Traps on overflow/underflow. +Converts an unsigned integer with infinite precision to an 8-bit unsigned integer. + +Traps on overflow. + +Example: +```motoko include=import +Nat8.fromNat(123); // => 123 : Nat8 +``` + +## Value `fromNat16` +``` motoko no-repl +let fromNat16 : Nat16 -> Nat8 +``` + +Converts a 16-bit unsigned integer to a 8-bit unsigned integer. + +Traps on overflow. + +Example: +```motoko include=import +Nat8.fromNat16(123); // => 123 : Nat8 +``` + +## Value `toNat16` +``` motoko no-repl +let toNat16 : Nat8 -> Nat16 +``` + +Converts an 8-bit unsigned integer to a 16-bit unsigned integer. + +Example: +```motoko include=import +Nat8.toNat16(123); // => 123 : Nat16 +``` ## Value `fromIntWrap` ``` motoko no-repl let fromIntWrap : Int -> Nat8 ``` -Conversion. Wraps on overflow/underflow. +Converts a signed integer with infinite precision to an 8-bit unsigned integer. + +Wraps on overflow/underflow. + +Example: +```motoko include=import +Nat8.fromIntWrap(123); // => 123 : Nat8 +``` ## Function `toText` ``` motoko no-repl func toText(x : Nat8) : Text ``` -Returns the Text representation of `x`. +Converts `x` to its textual representation. + +Example: +```motoko include=import +Nat8.toText(123); // => "123" : Text +``` ## Function `min` ``` motoko no-repl @@ -45,6 +112,11 @@ func min(x : Nat8, y : Nat8) : Nat8 Returns the minimum of `x` and `y`. +Example: +```motoko include=import +Nat8.min(123, 200); // => 123 : Nat8 +``` + ## Function `max` ``` motoko no-repl func max(x : Nat8, y : Nat8) : Nat8 @@ -52,84 +124,249 @@ func max(x : Nat8, y : Nat8) : Nat8 Returns the maximum of `x` and `y`. +Example: +```motoko include=import +Nat8.max(123, 200); // => 200 : Nat8 +``` + ## Function `equal` ``` motoko no-repl func equal(x : Nat8, y : Nat8) : Bool ``` -Returns `x == y`. +Equality function for Nat8 types. +This is equivalent to `x == y`. + +Example: +```motoko include=import +ignore Nat8.equal(1, 1); // => true +(1 : Nat8) == (1 : Nat8) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `==` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `==` +as a function value at the moment. + +Example: +```motoko include=import +import Buffer "mo:base/Buffer"; + +let buffer1 = Buffer.Buffer(3); +let buffer2 = Buffer.Buffer(3); +Buffer.equal(buffer1, buffer2, Nat8.equal) // => true +``` ## Function `notEqual` ``` motoko no-repl func notEqual(x : Nat8, y : Nat8) : Bool ``` -Returns `x != y`. +Inequality function for Nat8 types. +This is equivalent to `x != y`. + +Example: +```motoko include=import +ignore Nat8.notEqual(1, 2); // => true +(1 : Nat8) != (2 : Nat8) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `!=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `!=` +as a function value at the moment. ## Function `less` ``` motoko no-repl func less(x : Nat8, y : Nat8) : Bool ``` -Returns `x < y`. +"Less than" function for Nat8 types. +This is equivalent to `x < y`. + +Example: +```motoko include=import +ignore Nat8.less(1, 2); // => true +(1 : Nat8) < (2 : Nat8) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<` +as a function value at the moment. ## Function `lessOrEqual` ``` motoko no-repl func lessOrEqual(x : Nat8, y : Nat8) : Bool ``` -Returns `x <= y`. +"Less than or equal" function for Nat8 types. +This is equivalent to `x <= y`. + +Example: +```motoko include=import +ignore Nat.lessOrEqual(1, 2); // => true +1 <= 2 // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<=` +as a function value at the moment. ## Function `greater` ``` motoko no-repl func greater(x : Nat8, y : Nat8) : Bool ``` -Returns `x > y`. +"Greater than" function for Nat8 types. +This is equivalent to `x > y`. + +Example: +```motoko include=import +ignore Nat8.greater(2, 1); // => true +(2 : Nat8) > (1 : Nat8) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>` +as a function value at the moment. ## Function `greaterOrEqual` ``` motoko no-repl func greaterOrEqual(x : Nat8, y : Nat8) : Bool ``` -Returns `x >= y`. +"Greater than or equal" function for Nat8 types. +This is equivalent to `x >= y`. + +Example: +```motoko include=import +ignore Nat8.greaterOrEqual(2, 1); // => true +(2 : Nat8) >= (1 : Nat8) // => true +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>=` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>=` +as a function value at the moment. ## Function `compare` ``` motoko no-repl func compare(x : Nat8, y : Nat8) : {#less; #equal; #greater} ``` -Returns the order of `x` and `y`. +General purpose comparison function for `Nat8`. Returns the `Order` ( +either `#less`, `#equal`, or `#greater`) of comparing `x` with `y`. + +Example: +```motoko include=import +Nat8.compare(2, 3) // => #less +``` + +This function can be used as value for a high order function, such as a sort function. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.sort([2, 3, 1] : [Nat8], Nat8.compare) // => [1, 2, 3] +``` ## Function `add` ``` motoko no-repl func add(x : Nat8, y : Nat8) : Nat8 ``` -Returns the sum of `x` and `y`, `x + y`. Traps on overflow. +Returns the sum of `x` and `y`, `x + y`. +Traps on overflow. + +Example: +```motoko include=import +ignore Nat8.add(1, 2); // => 3 +(1 : Nat8) + (2 : Nat8) // => 3 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `+` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 0, Nat8.add) // => 6 +``` ## Function `sub` ``` motoko no-repl func sub(x : Nat8, y : Nat8) : Nat8 ``` -Returns the difference of `x` and `y`, `x - y`. Traps on underflow. +Returns the difference of `x` and `y`, `x - y`. +Traps on underflow. + +Example: +```motoko include=import +ignore Nat8.sub(2, 1); // => 1 +(2 : Nat8) - (1 : Nat8) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `-` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 20, Nat8.sub) // => 14 +``` ## Function `mul` ``` motoko no-repl func mul(x : Nat8, y : Nat8) : Nat8 ``` -Returns the product of `x` and `y`, `x * y`. Traps on overflow. +Returns the product of `x` and `y`, `x * y`. +Traps on overflow. + +Example: +```motoko include=import +ignore Nat8.mul(2, 3); // => 6 +(2 : Nat8) * (3 : Nat8) // => 6 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `*` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*` +as a function value at the moment. + +Example: +```motoko include=import +import Array "mo:base/Array"; +Array.foldLeft([2, 3, 1], 1, Nat8.mul) // => 6 +``` ## Function `div` ``` motoko no-repl func div(x : Nat8, y : Nat8) : Nat8 ``` -Returns the division of `x by y`, `x / y`. +Returns the quotient of `x` divided by `y`, `x / y`. Traps when `y` is zero. +Example: +```motoko include=import +ignore Nat8.div(6, 2); // => 3 +(6 : Nat8) / (2 : Nat8) // => 3 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `/` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `/` +as a function value at the moment. + ## Function `rem` ``` motoko no-repl func rem(x : Nat8, y : Nat8) : Nat8 @@ -138,12 +375,35 @@ func rem(x : Nat8, y : Nat8) : Nat8 Returns the remainder of `x` divided by `y`, `x % y`. Traps when `y` is zero. +Example: +```motoko include=import +ignore Nat8.rem(6, 4); // => 2 +(6 : Nat8) % (4 : Nat8) // => 2 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `%` +as a function value at the moment. + ## Function `pow` ``` motoko no-repl func pow(x : Nat8, y : Nat8) : Nat8 ``` -Returns `x` to the power of `y`, `x ** y`. Traps on overflow. +Returns `x` to the power of `y`, `x ** y`. +Traps on overflow. + +Example: +```motoko include=import +ignore Nat8.pow(2, 3); // => 8 +(2 : Nat8) ** (3 : Nat8) // => 8 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**` +as a function value at the moment. ## Function `bitnot` ``` motoko no-repl @@ -152,6 +412,17 @@ func bitnot(x : Nat8) : Nat8 Returns the bitwise negation of `x`, `^x`. +Example: +```motoko include=import +ignore Nat8.bitnot(0); // => 255 +^(0 : Nat8) // => 255 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitand` ``` motoko no-repl func bitand(x : Nat8, y : Nat8) : Nat8 @@ -159,12 +430,34 @@ func bitand(x : Nat8, y : Nat8) : Nat8 Returns the bitwise and of `x` and `y`, `x & y`. +Example: +```motoko include=import +ignore Nat8.bitand(3, 2); // => 2 +(3 : Nat8) & (2 : Nat8) // => 2 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `&` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `&` +as a function value at the moment. + ## Function `bitor` ``` motoko no-repl func bitor(x : Nat8, y : Nat8) : Nat8 ``` -Returns the bitwise or of `x` and `y`, `x \| y`. +Returns the bitwise or of `x` and `y`, `x | y`. + +Example: +```motoko include=import +ignore Nat8.bitor(3, 2); // => 3 +(3 : Nat8) | (2 : Nat8) // => 3 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `|` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `|` +as a function value at the moment. ## Function `bitxor` ``` motoko no-repl @@ -173,6 +466,17 @@ func bitxor(x : Nat8, y : Nat8) : Nat8 Returns the bitwise exclusive or of `x` and `y`, `x ^ y`. +Example: +```motoko include=import +ignore Nat8.bitxor(3, 2); // => 1 +(3 : Nat8) ^ (2 : Nat8) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `^` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `^` +as a function value at the moment. + ## Function `bitshiftLeft` ``` motoko no-repl func bitshiftLeft(x : Nat8, y : Nat8) : Nat8 @@ -180,6 +484,17 @@ func bitshiftLeft(x : Nat8, y : Nat8) : Nat8 Returns the bitwise shift left of `x` by `y`, `x << y`. +Example: +```motoko include=import +ignore Nat8.bitshiftLeft(1, 2); // => 4 +(1 : Nat8) << (2 : Nat8) // => 4 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<<` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<` +as a function value at the moment. + ## Function `bitshiftRight` ``` motoko no-repl func bitshiftRight(x : Nat8, y : Nat8) : Nat8 @@ -187,6 +502,17 @@ func bitshiftRight(x : Nat8, y : Nat8) : Nat8 Returns the bitwise shift right of `x` by `y`, `x >> y`. +Example: +```motoko include=import +ignore Nat8.bitshiftRight(4, 2); // => 1 +(4 : Nat8) >> (2 : Nat8) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `>>` +as a function value at the moment. + ## Function `bitrotLeft` ``` motoko no-repl func bitrotLeft(x : Nat8, y : Nat8) : Nat8 @@ -194,6 +520,17 @@ func bitrotLeft(x : Nat8, y : Nat8) : Nat8 Returns the bitwise rotate left of `x` by `y`, `x <<> y`. +Example: +```motoko include=import +ignore Nat8.bitrotLeft(128, 1); // => 1 +(128 : Nat8) <<> (1 : Nat8) // => 1 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<<>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<<>` +as a function value at the moment. + ## Function `bitrotRight` ``` motoko no-repl func bitrotRight(x : Nat8, y : Nat8) : Nat8 @@ -201,12 +538,29 @@ func bitrotRight(x : Nat8, y : Nat8) : Nat8 Returns the bitwise rotate right of `x` by `y`, `x <>> y`. +Example: +```motoko include=import +ignore Nat8.bitrotRight(1, 1); // => 128 +(1 : Nat8) <>> (1 : Nat8) // => 128 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `<>>` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `<>>` +as a function value at the moment. + ## Function `bittest` ``` motoko no-repl func bittest(x : Nat8, p : Nat) : Bool ``` Returns the value of bit `p mod 8` in `x`, `(x & 2^(p mod 8)) == 2^(p mod 8)`. +This is equivalent to checking if the `p`-th bit is set in `x`, using 0 indexing. + +Example: +```motoko include=import +Nat8.bittest(5, 2); // => true +``` ## Function `bitset` ``` motoko no-repl @@ -215,6 +569,11 @@ func bitset(x : Nat8, p : Nat) : Nat8 Returns the value of setting bit `p mod 8` in `x` to `1`. +Example: +```motoko include=import +Nat8.bitset(5, 1); // => 7 +``` + ## Function `bitclear` ``` motoko no-repl func bitclear(x : Nat8, p : Nat) : Nat8 @@ -222,6 +581,11 @@ func bitclear(x : Nat8, p : Nat) : Nat8 Returns the value of clearing bit `p mod 8` in `x` to `0`. +Example: +```motoko include=import +Nat8.bitclear(5, 2); // => 1 +``` + ## Function `bitflip` ``` motoko no-repl func bitflip(x : Nat8, p : Nat) : Nat8 @@ -229,6 +593,11 @@ func bitflip(x : Nat8, p : Nat) : Nat8 Returns the value of flipping bit `p mod 8` in `x`. +Example: +```motoko include=import +Nat8.bitflip(5, 2); // => 1 +``` + ## Value `bitcountNonZero` ``` motoko no-repl let bitcountNonZero : (x : Nat8) -> Nat8 @@ -236,6 +605,11 @@ let bitcountNonZero : (x : Nat8) -> Nat8 Returns the count of non-zero bits in `x`. +Example: +```motoko include=import +Nat8.bitcountNonZero(5); // => 2 +``` + ## Value `bitcountLeadingZero` ``` motoko no-repl let bitcountLeadingZero : (x : Nat8) -> Nat8 @@ -243,6 +617,11 @@ let bitcountLeadingZero : (x : Nat8) -> Nat8 Returns the count of leading zero bits in `x`. +Example: +```motoko include=import +Nat8.bitcountLeadingZero(5); // => 5 +``` + ## Value `bitcountTrailingZero` ``` motoko no-repl let bitcountTrailingZero : (x : Nat8) -> Nat8 @@ -250,6 +629,11 @@ let bitcountTrailingZero : (x : Nat8) -> Nat8 Returns the count of trailing zero bits in `x`. +Example: +```motoko include=import +Nat8.bitcountTrailingZero(6); // => 1 +``` + ## Function `addWrap` ``` motoko no-repl func addWrap(x : Nat8, y : Nat8) : Nat8 @@ -257,6 +641,17 @@ func addWrap(x : Nat8, y : Nat8) : Nat8 Returns the sum of `x` and `y`, `x +% y`. Wraps on overflow. +Example: +```motoko include=import +ignore Nat8.addWrap(230, 26); // => 0 +(230 : Nat8) +% (26 : Nat8) // => 0 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `+%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `+%` +as a function value at the moment. + ## Function `subWrap` ``` motoko no-repl func subWrap(x : Nat8, y : Nat8) : Nat8 @@ -264,6 +659,16 @@ func subWrap(x : Nat8, y : Nat8) : Nat8 Returns the difference of `x` and `y`, `x -% y`. Wraps on underflow. +Example: +```motoko include=import +ignore Nat8.subWrap(0, 1); // => 255 +(0 : Nat8) -% (1 : Nat8) // => 255 +``` +Note: The reason why this function is defined in this library (in addition +to the existing `-%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `-%` +as a function value at the moment. + ## Function `mulWrap` ``` motoko no-repl func mulWrap(x : Nat8, y : Nat8) : Nat8 @@ -271,9 +676,31 @@ func mulWrap(x : Nat8, y : Nat8) : Nat8 Returns the product of `x` and `y`, `x *% y`. Wraps on overflow. +Example: +```motoko include=import +ignore Nat8.mulWrap(230, 26); // => 92 +(230 : Nat8) *% (26 : Nat8) // => 92 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `*%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `*%` +as a function value at the moment. + ## Function `powWrap` ``` motoko no-repl func powWrap(x : Nat8, y : Nat8) : Nat8 ``` Returns `x` to the power of `y`, `x **% y`. Wraps on overflow. + +Example: +```motoko include=import +ignore Nat8.powWrap(2, 8); // => 0 +(2 : Nat8) **% (8 : Nat8) // => 0 +``` + +Note: The reason why this function is defined in this library (in addition +to the existing `**%` operator) is so that you can use it as a function +value to pass to a higher order function. It is not possible to use `**%` +as a function value at the moment. diff --git a/doc/md/base/Option.md b/doc/md/base/Option.md index 7acf1548052..8bf84923aa8 100644 --- a/doc/md/base/Option.md +++ b/doc/md/base/Option.md @@ -124,6 +124,13 @@ func isNull(x : ?Any) : Bool Returns true if the argument is `null`, otherwise returns false. +## Function `equal` +``` motoko no-repl +func equal(x : ?A, y : ?A, eq : (A, A) -> Bool) : Bool +``` + +Returns true if the optional arguments are equal according to the equality function provided, otherwise returns false. + ## Function `assertSome` ``` motoko no-repl func assertSome(x : ?Any) diff --git a/doc/md/base/OrderedMap.md b/doc/md/base/OrderedMap.md new file mode 100644 index 00000000000..6a2302f3fc8 --- /dev/null +++ b/doc/md/base/OrderedMap.md @@ -0,0 +1,739 @@ +# OrderedMap +Stable key-value map implemented as a red-black tree with nodes storing key-value pairs. + +A red-black tree is a balanced binary search tree ordered by the keys. + +The tree data structure internally colors each of its nodes either red or black, +and uses this information to balance the tree during the modifying operations. + +Performance: +* Runtime: `O(log(n))` worst case cost per insertion, removal, and retrieval operation. +* Space: `O(n)` for storing the entire tree. +`n` denotes the number of key-value entries (i.e. nodes) stored in the tree. + +Note: +* Map operations, such as retrieval, insertion, and removal create `O(log(n))` temporary objects that become garbage. + +Credits: + +The core of this implementation is derived from: + +* Ken Friis Larsen's [RedBlackMap.sml](https://github.com/kfl/mosml/blob/master/src/mosmllib/Redblackmap.sml), which itself is based on: +* Stefan Kahrs, "Red-black trees with types", Journal of Functional Programming, 11(4): 425-432 (2001), [version 1 in web appendix](http://www.cs.ukc.ac.uk/people/staff/smk/redblack/rb.html). + +## Type `Map` +``` motoko no-repl +type Map = { size : Nat; root : Tree } +``` + +Collection of key-value entries, ordered by the keys and key unique. +The keys have the generic type `K` and the values the generic type `V`. +If `K` and `V` is stable types then `Map` is also stable. +To ensure that property the `Map` does not have any methods, instead +they are gathered in the functor-like class `Operations` (see example there). + +## Class `Operations` + +``` motoko no-repl +class Operations(compare : (K, K) -> O.Order) +``` + +Class that captures key type `K` along with its ordering function `compare` +and provides all operations to work with a map of type `Map`. + +An instance object should be created once as a canister field to ensure +that the same ordering function is used for every operation. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; + +actor { + let natMap = Map.Make(Nat.compare); // : Operations + stable var keyStorage : Map.Map = natMap.empty(); + + public func addKey(id : Nat, key : Text) : async () { + keyStorage := natMap.put(keyStorage, id, key); + } +} +``` + +### Function `fromIter` +``` motoko no-repl +func fromIter(i : I.Iter<(K, V)>) : Map +``` + +Returns a new map, containing all entries given by the iterator `i`. +If there are multiple entries with the same key the last one is taken. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let m = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +Debug.print(debug_show(Iter.toArray(natMap.entries(m)))); + +// [(0, "Zero"), (1, "One"), (2, "Two")] +``` + +Runtime: `O(n * log(n))`. +Space: `O(n)` retained memory plus garbage, see the note below. +where `n` denotes the number of key-value entries stored in the map and +assuming that the `compare` function implements an `O(1)` comparison. + +Note: Creates `O(n * log(n))` temporary objects that will be collected as garbage. + + +### Function `put` +``` motoko no-repl +func put(m : Map, key : K, value : V) : Map +``` + +Insert the value `value` with key `key` into the map `m`. Overwrites any existing entry with key `key`. +Returns a modified map. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +var map = natMap.empty(); + +map := natMap.put(map, 0, "Zero"); +map := natMap.put(map, 2, "Two"); +map := natMap.put(map, 1, "One"); + +Debug.print(debug_show(Iter.toArray(natMap.entries(map)))); + +// [(0, "Zero"), (1, "One"), (2, "Two")] +``` + +Runtime: `O(log(n))`. +Space: `O(log(n))`. +where `n` denotes the number of key-value entries stored in the map and +assuming that the `compare` function implements an `O(1)` comparison. + +Note: The returned map shares with the `m` most of the tree nodes. +Garbage collecting one of maps (e.g. after an assignment `m := natMap.put(m, k)`) +causes collecting `O(log(n))` nodes. + + +### Function `replace` +``` motoko no-repl +func replace(m : Map, key : K, value : V) : (Map, ?V) +``` + +Insert the value `value` with key `key` into the map `m`. Returns modified map and +the previous value associated with key `key` or `null` if no such value exists. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map0 = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +let (map1, old1) = natMap.replace(map0, 0, "Nil"); + +Debug.print(debug_show(Iter.toArray(natMap.entries(map1)))); +Debug.print(debug_show(old1)); +// [(0, "Nil"), (1, "One"), (2, "Two")] +// ?"Zero" + +let (map2, old2) = natMap.replace(map0, 3, "Three"); + +Debug.print(debug_show(Iter.toArray(natMap.entries(map2)))); +Debug.print(debug_show(old2)); +// [(0, "Zero"), (1, "One"), (2, "Two"), (3, "Three")] +// null +``` + +Runtime: `O(log(n))`. +Space: `O(log(n))` retained memory plus garbage, see the note below. +where `n` denotes the number of key-value entries stored in the map and +assuming that the `compare` function implements an `O(1)` comparison. + +Note: The returned map shares with the `m` most of the tree nodes. +Garbage collecting one of maps (e.g. after an assignment `m := natMap.replace(m, k).0`) +causes collecting `O(log(n))` nodes. + + +### Function `mapFilter` +``` motoko no-repl +func mapFilter(m : Map, f : (K, V1) -> ?V2) : Map +``` + +Creates a new map by applying `f` to each entry in the map `m`. For each entry +`(k, v)` in the old map, if `f` evaluates to `null`, the entry is discarded. +Otherwise, the entry is transformed into a new entry `(k, v2)`, where +the new value `v2` is the result of applying `f` to `(k, v)`. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +func f(key : Nat, val : Text) : ?Text { + if(key == 0) {null} + else { ?("Twenty " # val)} +}; + +let newMap = natMap.mapFilter(map, f); + +Debug.print(debug_show(Iter.toArray(natMap.entries(newMap)))); + +// [(1, "Twenty One"), (2, "Twenty Two")] +``` + +Runtime: `O(n * log(n))`. +Space: `O(n)` retained memory plus garbage, see the note below. +where `n` denotes the number of key-value entries stored in the map and +assuming that the `compare` function implements an `O(1)` comparison. + +Note: Creates `O(n * log(n))` temporary objects that will be collected as garbage. + + +### Function `get` +``` motoko no-repl +func get(m : Map, key : K) : ?V +``` + +Get the value associated with key `key` in the given map `m` if present and `null` otherwise. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +Debug.print(debug_show(natMap.get(map, 1))); +Debug.print(debug_show(natMap.get(map, 42))); + +// ?"One" +// null +``` + +Runtime: `O(log(n))`. +Space: `O(1)`. +where `n` denotes the number of key-value entries stored in the map and +assuming that the `compare` function implements an `O(1)` comparison. + + +### Function `contains` +``` motoko no-repl +func contains(m : Map, key : K) : Bool +``` + +Test whether the map `m` contains any binding for the given `key`. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +Debug.print(debug_show natMap.contains(map, 1)); // => true +Debug.print(debug_show natMap.contains(map, 42)); // => false +``` + +Runtime: `O(log(n))`. +Space: `O(1)`. +where `n` denotes the number of key-value entries stored in the map and +assuming that the `compare` function implements an `O(1)` comparison. + + +### Function `maxEntry` +``` motoko no-repl +func maxEntry(m : Map) : ?(K, V) +``` + +Retrieves a key-value pair from the map `m` with a maximal key. If the map is empty returns `null`. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +Debug.print(debug_show(natMap.maxEntry(map))); // => ?(2, "Two") +Debug.print(debug_show(natMap.maxEntry(natMap.empty()))); // => null +``` + +Runtime: `O(log(n))`. +Space: `O(1)`. +where `n` denotes the number of key-value entries stored in the map. + + +### Function `minEntry` +``` motoko no-repl +func minEntry(m : Map) : ?(K, V) +``` + +Retrieves a key-value pair from the map `m` with a minimal key. If the map is empty returns `null`. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Iter "mo:base/Iter"; +import Nat "mo:base/Nat"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +Debug.print(debug_show(natMap.minEntry(map))); // => ?(0, "Zero") +Debug.print(debug_show(natMap.minEntry(natMap.empty()))); // => null +``` + +Runtime: `O(log(n))`. +Space: `O(1)`. +where `n` denotes the number of key-value entries stored in the map. + + +### Function `delete` +``` motoko no-repl +func delete(m : Map, key : K) : Map +``` + +Deletes the entry with the key `key` from the map `m`. Has no effect if `key` is not +present in the map. Returns modified map. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +Debug.print(debug_show(Iter.toArray(natMap.entries(natMap.delete(map, 1))))); +Debug.print(debug_show(Iter.toArray(natMap.entries(natMap.delete(map, 42))))); + +// [(0, "Zero"), (2, "Two")] +// [(0, "Zero"), (1, "One"), (2, "Two")] +``` + +Runtime: `O(log(n))`. +Space: `O(log(n))` +where `n` denotes the number of key-value entries stored in the map and +assuming that the `compare` function implements an `O(1)` comparison. + +Note: The returned map shares with the `m` most of the tree nodes. +Garbage collecting one of maps (e.g. after an assignment `m := natMap.delete(m, k).0`) +causes collecting `O(log(n))` nodes. + + +### Function `remove` +``` motoko no-repl +func remove(m : Map, key : K) : (Map, ?V) +``` + +Deletes the entry with the key `key`. Returns modified map and the +previous value associated with key `key` or `null` if no such value exists. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map0 = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +let (map1, old1) = natMap.remove(map0, 0); + +Debug.print(debug_show(Iter.toArray(natMap.entries(map1)))); +Debug.print(debug_show(old1)); +// [(1, "One"), (2, "Two")] +// ?"Zero" + +let (map2, old2) = natMap.remove(map0, 42); + +Debug.print(debug_show(Iter.toArray(natMap.entries(map2)))); +Debug.print(debug_show(old2)); +// [(0, "Zero"), (1, "One"), (2, "Two")] +// null +``` + +Runtime: `O(log(n))`. +Space: `O(log(n))`. +where `n` denotes the number of key-value entries stored in the map and +assuming that the `compare` function implements an `O(1)` comparison. + +Note: The returned map shares with the `m` most of the tree nodes. +Garbage collecting one of maps (e.g. after an assignment `m := natMap.remove(m, k)`) +causes collecting `O(log(n))` nodes. + + +### Function `empty` +``` motoko no-repl +func empty() : Map +``` + +Create a new empty map. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); + +let map = natMap.empty(); + +Debug.print(debug_show(natMap.size(map))); + +// 0 +``` + +Cost of empty map creation +Runtime: `O(1)`. +Space: `O(1)` + + +### Function `entries` +``` motoko no-repl +func entries(m : Map) : I.Iter<(K, V)> +``` + +Returns an Iterator (`Iter`) over the key-value pairs in the map. +Iterator provides a single method `next()`, which returns +pairs in ascending order by keys, or `null` when out of pairs to iterate over. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +Debug.print(debug_show(Iter.toArray(natMap.entries(map)))); +// [(0, "Zero"), (1, "One"), (2, "Two")] +var sum = 0; +for ((k, _) in natMap.entries(map)) { sum += k; }; +Debug.print(debug_show(sum)); // => 3 +``` +Cost of iteration over all elements: +Runtime: `O(n)`. +Space: `O(log(n))` retained memory plus garbage, see the note below. +where `n` denotes the number of key-value entries stored in the map. + +Note: Full map iteration creates `O(n)` temporary objects that will be collected as garbage. + + +### Function `entriesRev` +``` motoko no-repl +func entriesRev(m : Map) : I.Iter<(K, V)> +``` + +Same as `entries` but iterates in the descending order. + + +### Function `keys` +``` motoko no-repl +func keys(m : Map) : I.Iter +``` + +Returns an Iterator (`Iter`) over the keys of the map. +Iterator provides a single method `next()`, which returns +keys in ascending order, or `null` when out of keys to iterate over. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +Debug.print(debug_show(Iter.toArray(natMap.keys(map)))); + +// [0, 1, 2] +``` +Cost of iteration over all elements: +Runtime: `O(n)`. +Space: `O(log(n))` retained memory plus garbage, see the note below. +where `n` denotes the number of key-value entries stored in the map. + +Note: Full map iteration creates `O(n)` temporary objects that will be collected as garbage. + + +### Function `vals` +``` motoko no-repl +func vals(m : Map) : I.Iter +``` + +Returns an Iterator (`Iter`) over the values of the map. +Iterator provides a single method `next()`, which returns +values in ascending order of associated keys, or `null` when out of values to iterate over. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +Debug.print(debug_show(Iter.toArray(natMap.vals(map)))); + +// ["Zero", "One", "Two"] +``` +Cost of iteration over all elements: +Runtime: `O(n)`. +Space: `O(log(n))` retained memory plus garbage, see the note below. +where `n` denotes the number of key-value entries stored in the map. + +Note: Full map iteration creates `O(n)` temporary objects that will be collected as garbage. + + +### Function `map` +``` motoko no-repl +func map(m : Map, f : (K, V1) -> V2) : Map +``` + +Creates a new map by applying `f` to each entry in the map `m`. Each entry +`(k, v)` in the old map is transformed into a new entry `(k, v2)`, where +the new value `v2` is created by applying `f` to `(k, v)`. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +func f(key : Nat, _val : Text) : Nat = key * 2; + +let resMap = natMap.map(map, f); + +Debug.print(debug_show(Iter.toArray(natMap.entries(resMap)))); +// [(0, 0), (1, 2), (2, 4)] +``` + +Cost of mapping all the elements: +Runtime: `O(n)`. +Space: `O(n)` retained memory +where `n` denotes the number of key-value entries stored in the map. + + +### Function `size` +``` motoko no-repl +func size(m : Map) : Nat +``` + +Determine the size of the map as the number of key-value entries. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +Debug.print(debug_show(natMap.size(map))); +// 3 +``` + +Runtime: `O(n)`. +Space: `O(1)`. + + +### Function `foldLeft` +``` motoko no-repl +func foldLeft(map : Map, base : Accum, combine : (Accum, K, Value) -> Accum) : Accum +``` + +Collapses the elements in the `map` into a single value by starting with `base` +and progressively combining keys and values into `base` with `combine`. Iteration runs +left to right. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +func folder(accum : (Nat, Text), key : Nat, val : Text) : ((Nat, Text)) + = (key + accum.0, accum.1 # val); + +Debug.print(debug_show(natMap.foldLeft(map, (0, ""), folder))); + +// (3, "ZeroOneTwo") +``` + +Cost of iteration over all elements: +Runtime: `O(n)`. +Space: depends on `combine` function plus garbage, see the note below. +where `n` denotes the number of key-value entries stored in the map. + +Note: Full map iteration creates `O(n)` temporary objects that will be collected as garbage. + + +### Function `foldRight` +``` motoko no-repl +func foldRight(map : Map, base : Accum, combine : (K, Value, Accum) -> Accum) : Accum +``` + +Collapses the elements in the `map` into a single value by starting with `base` +and progressively combining keys and values into `base` with `combine`. Iteration runs +right to left. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "Zero"), (2, "Two"), (1, "One")])); + +func folder(key : Nat, val : Text, accum : (Nat, Text)) : ((Nat, Text)) + = (key + accum.0, accum.1 # val); + +Debug.print(debug_show(natMap.foldRight(map, (0, ""), folder))); + +// (3, "TwoOneZero") +``` + +Cost of iteration over all elements: +Runtime: `O(n)`. +Space: depends on `combine` function plus garbage, see the note below. +where `n` denotes the number of key-value entries stored in the map. + +Note: Full map iteration creates `O(n)` temporary objects that will be collected as garbage. + + +### Function `all` +``` motoko no-repl +func all(m : Map, pred : (K, V) -> Bool) : Bool +``` + +Test whether all key-value pairs satisfy a given predicate `pred`. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "0"), (2, "2"), (1, "1")])); + +Debug.print(debug_show(natMap.all(map, func (k, v) = (v == debug_show(k))))); +// true +Debug.print(debug_show(natMap.all(map, func (k, v) = (k < 2)))); +// false +``` + +Runtime: `O(n)`. +Space: `O(1)`. +where `n` denotes the number of key-value entries stored in the map. + + +### Function `some` +``` motoko no-repl +func some(m : Map, pred : (K, V) -> Bool) : Bool +``` + +Test if there exists a key-value pair satisfying a given predicate `pred`. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natMap = Map.Make(Nat.compare); +let map = natMap.fromIter(Iter.fromArray([(0, "0"), (2, "2"), (1, "1")])); + +Debug.print(debug_show(natMap.some(map, func (k, v) = (k >= 3)))); +// false +Debug.print(debug_show(natMap.some(map, func (k, v) = (k >= 0)))); +// true +``` + +Runtime: `O(n)`. +Space: `O(1)`. +where `n` denotes the number of key-value entries stored in the map. + + +### Function `validate` +``` motoko no-repl +func validate(m : Map) : () +``` + +Debug helper that check internal invariants of the given map `m`. +Raise an error (for a stack trace) if invariants are violated. + +## Value `Make` +``` motoko no-repl +let Make : (compare : (K, K) -> O.Order) -> Operations +``` + +Create `OrderedMap.Operations` object capturing key type `K` and `compare` function. +It is an alias for the `Operations` constructor. + +Example: +```motoko +import Map "mo:base/OrderedMap"; +import Nat "mo:base/Nat"; + +actor { + let natMap = Map.Make(Nat.compare); + stable var map : Map.Map = natMap.empty(); +}; +``` diff --git a/doc/md/base/OrderedSet.md b/doc/md/base/OrderedSet.md new file mode 100644 index 00000000000..97495b55ef3 --- /dev/null +++ b/doc/md/base/OrderedSet.md @@ -0,0 +1,736 @@ +# OrderedSet +Stable ordered set implemented as a red-black tree. + +A red-black tree is a balanced binary search tree ordered by the elements. + +The tree data structure internally colors each of its nodes either red or black, +and uses this information to balance the tree during the modifying operations. + +Performance: +* Runtime: `O(log(n))` worst case cost per insertion, removal, and retrieval operation. +* Space: `O(n)` for storing the entire tree. +`n` denotes the number of elements (i.e. nodes) stored in the tree. + +Credits: + +The core of this implementation is derived from: + +* Ken Friis Larsen's [RedBlackMap.sml](https://github.com/kfl/mosml/blob/master/src/mosmllib/Redblackmap.sml), which itself is based on: +* Stefan Kahrs, "Red-black trees with types", Journal of Functional Programming, 11(4): 425-432 (2001), [version 1 in web appendix](http://www.cs.ukc.ac.uk/people/staff/smk/redblack/rb.html). + +## Type `Set` +``` motoko no-repl +type Set = { size : Nat; root : Tree } +``` + +Ordered collection of unique elements of the generic type `T`. +If type `T` is stable then `Set` is also stable. +To ensure that property the `Set` does not have any methods, +instead they are gathered in the functor-like class `Operations` (see example there). + +## Class `Operations` + +``` motoko no-repl +class Operations(compare : (T, T) -> O.Order) +``` + +Class that captures element type `T` along with its ordering function `compare` +and provide all operations to work with a set of type `Set`. + +An instance object should be created once as a canister field to ensure +that the same ordering function is used for every operation. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; + +actor { + let natSet = Set.Make(Nat.compare); // : Operations + stable var usedIds : Set.Set = natSet.empty(); + + public func createId(id : Nat) : async () { + usedIds := natSet.put(usedIds, id); + }; + + public func idIsUsed(id: Nat) : async Bool { + natSet.contains(usedIds, id) + } +} +``` + +### Function `fromIter` +``` motoko no-repl +func fromIter(i : I.Iter) : Set +``` + +Returns a new Set, containing all entries given by the iterator `i`. +If there are multiple identical entries only one is taken. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 2, 1])); + +Debug.print(debug_show(Iter.toArray(natSet.vals(set)))); +// [0, 1, 2] +``` + +Runtime: `O(n * log(n))`. +Space: `O(n)` retained memory plus garbage, see the note below. +where `n` denotes the number of elements stored in the set and +assuming that the `compare` function implements an `O(1)` comparison. + +Note: Creates `O(n * log(n))` temporary objects that will be collected as garbage. + + +### Function `put` +``` motoko no-repl +func put(s : Set, value : T) : Set +``` + +Insert the value `value` into the set `s`. Has no effect if `value` is already +present in the set. Returns a modified set. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +var set = natSet.empty(); + +set := natSet.put(set, 0); +set := natSet.put(set, 2); +set := natSet.put(set, 1); + +Debug.print(debug_show(Iter.toArray(natSet.vals(set)))); +// [0, 1, 2] +``` + +Runtime: `O(log(n))`. +Space: `O(log(n))`. +where `n` denotes the number of elements stored in the set and +assuming that the `compare` function implements an `O(1)` comparison. + +Note: The returned set shares with the `s` most of the tree nodes. +Garbage collecting one of sets (e.g. after an assignment `m := natSet.delete(m, k)`) +causes collecting `O(log(n))` nodes. + + +### Function `delete` +``` motoko no-repl +func delete(s : Set, value : T) : Set +``` + +Deletes the value `value` from the set `s`. Has no effect if `value` is not +present in the set. Returns modified set. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 2, 1])); + +Debug.print(debug_show(Iter.toArray(natSet.vals(natSet.delete(set, 1))))); +Debug.print(debug_show(Iter.toArray(natSet.vals(natSet.delete(set, 42))))); +// [0, 2] +// [0, 1, 2] +``` + +Runtime: `O(log(n))`. +Space: `O(log(n))`. +where `n` denotes the number of elements stored in the set and +assuming that the `compare` function implements an `O(1)` comparison. + +Note: The returned set shares with the `s` most of the tree nodes. +Garbage collecting one of sets (e.g. after an assignment `m := natSet.delete(m, k)`) +causes collecting `O(log(n))` nodes. + + +### Function `contains` +``` motoko no-repl +func contains(s : Set, value : T) : Bool +``` + +Test if the set 's' contains a given element. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 2, 1])); + +Debug.print(debug_show natSet.contains(set, 1)); // => true +Debug.print(debug_show natSet.contains(set, 42)); // => false +``` + +Runtime: `O(log(n))`. +Space: `O(1)` retained memory plus garbage, see the note below. +where `n` denotes the number of elements stored in the set and +assuming that the `compare` function implements an `O(1)` comparison. + + +### Function `max` +``` motoko no-repl +func max(s : Set) : ?T +``` + +Get a maximal element of the set `s` if it is not empty, otherwise returns `null` + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let s1 = natSet.fromIter(Iter.fromArray([0, 2, 1])); +let s2 = natSet.empty(); + +Debug.print(debug_show(natSet.max(s1))); // => ?2 +Debug.print(debug_show(natSet.max(s2))); // => null +``` + +Runtime: `O(log(n))`. +Space: `O(1)`. +where `n` denotes the number of elements in the set + + +### Function `min` +``` motoko no-repl +func min(s : Set) : ?T +``` + +Get a minimal element of the set `s` if it is not empty, otherwise returns `null` + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let s1 = natSet.fromIter(Iter.fromArray([0, 2, 1])); +let s2 = natSet.empty(); + +Debug.print(debug_show(natSet.min(s1))); // => ?0 +Debug.print(debug_show(natSet.min(s2))); // => null +``` + +Runtime: `O(log(n))`. +Space: `O(1)`. +where `n` denotes the number of elements in the set + + +### Function `union` +``` motoko no-repl +func union(s1 : Set, s2 : Set) : Set +``` + +[Set union](https://en.wikipedia.org/wiki/Union_(set_theory)) operation. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set1 = natSet.fromIter(Iter.fromArray([0, 1, 2])); +let set2 = natSet.fromIter(Iter.fromArray([2, 3, 4])); + +Debug.print(debug_show Iter.toArray(natSet.vals(natSet.union(set1, set2)))); +// [0, 1, 2, 3, 4] +``` + +Runtime: `O(m * log(n))`. +Space: `O(m)`, retained memory plus garbage, see the note below. +where `m` and `n` denote the number of elements in the sets, and `m <= n`. + +Note: Creates `O(m * log(n))` temporary objects that will be collected as garbage. + + +### Function `intersect` +``` motoko no-repl +func intersect(s1 : Set, s2 : Set) : Set +``` + +[Set intersection](https://en.wikipedia.org/wiki/Intersection_(set_theory)) operation. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set1 = natSet.fromIter(Iter.fromArray([0, 1, 2])); +let set2 = natSet.fromIter(Iter.fromArray([1, 2, 3])); + +Debug.print(debug_show Iter.toArray(natSet.vals(natSet.intersect(set1, set2)))); +// [1, 2] +``` + +Runtime: `O(m * log(n))`. +Space: `O(m)`, retained memory plus garbage, see the note below. +where `m` and `n` denote the number of elements in the sets, and `m <= n`. + +Note: Creates `O(m)` temporary objects that will be collected as garbage. + + +### Function `diff` +``` motoko no-repl +func diff(s1 : Set, s2 : Set) : Set +``` + +[Set difference](https://en.wikipedia.org/wiki/Difference_(set_theory)). + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set1 = natSet.fromIter(Iter.fromArray([0, 1, 2])); +let set2 = natSet.fromIter(Iter.fromArray([1, 2, 3])); + +Debug.print(debug_show Iter.toArray(natSet.vals(natSet.diff(set1, set2)))); +// [0] +``` + +Runtime: `O(m * log(n))`. +Space: `O(m)`, retained memory plus garbage, see the note below. +where `m` and `n` denote the number of elements in the sets, and `m <= n`. + +Note: Creates `O(m * log(n))` temporary objects that will be collected as garbage. + + +### Function `map` +``` motoko no-repl +func map(s : Set, f : T1 -> T) : Set +``` + +Creates a new `Set` by applying `f` to each entry in the set `s`. Each element +`x` in the old set is transformed into a new entry `x2`, where +the new value `x2` is created by applying `f` to `x`. +The result set may be smaller than the original set due to duplicate elements. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 1, 2, 3])); + +func f(x : Nat) : Nat = if (x < 2) { x } else { 0 }; + +let resSet = natSet.map(set, f); + +Debug.print(debug_show(Iter.toArray(natSet.vals(resSet)))); +// [0, 1] +``` + +Cost of mapping all the elements: +Runtime: `O(n * log(n))`. +Space: `O(n)` retained memory +where `n` denotes the number of elements stored in the set. + +Note: Creates `O(n * log(n))` temporary objects that will be collected as garbage. + + +### Function `mapFilter` +``` motoko no-repl +func mapFilter(s : Set, f : T1 -> ?T) : Set +``` + +Creates a new set by applying `f` to each element in the set `s`. For each element +`x` in the old set, if `f` evaluates to `null`, the element is discarded. +Otherwise, the entry is transformed into a new entry `x2`, where +the new value `x2` is the result of applying `f` to `x`. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 1, 2, 3])); + +func f(x : Nat) : ?Nat { + if(x == 0) {null} + else { ?( x * 2 )} +}; + +let newRbSet = natSet.mapFilter(set, f); + +Debug.print(debug_show(Iter.toArray(natSet.vals(newRbSet)))); +// [2, 4, 6] +``` + +Runtime: `O(n * log(n))`. +Space: `O(n)` retained memory plus garbage, see the note below. +where `n` denotes the number of elements stored in the set and +assuming that the `compare` function implements an `O(1)` comparison. + +Note: Creates `O(n * log(n))` temporary objects that will be collected as garbage. + + +### Function `isSubset` +``` motoko no-repl +func isSubset(s1 : Set, s2 : Set) : Bool +``` + +Test if `set1` is subset of `set2`. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set1 = natSet.fromIter(Iter.fromArray([1, 2])); +let set2 = natSet.fromIter(Iter.fromArray([0, 2, 1])); + +Debug.print(debug_show natSet.isSubset(set1, set2)); // => true +``` + +Runtime: `O(m * log(n))`. +Space: `O(1)` retained memory plus garbage, see the note below. +where `m` and `n` denote the number of elements stored in the sets set1 and set2, respectively, +and assuming that the `compare` function implements an `O(1)` comparison. + + +### Function `equals` +``` motoko no-repl +func equals(s1 : Set, s2 : Set) : Bool +``` + +Test if two sets are equal. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set1 = natSet.fromIter(Iter.fromArray([0, 2, 1])); +let set2 = natSet.fromIter(Iter.fromArray([1, 2])); + +Debug.print(debug_show natSet.equals(set1, set1)); // => true +Debug.print(debug_show natSet.equals(set1, set2)); // => false +``` + +Runtime: `O(m * log(n))`. +Space: `O(1)` retained memory plus garbage, see the note below. +where `m` and `n` denote the number of elements stored in the sets set1 and set2, respectively, +and assuming that the `compare` function implements an `O(1)` comparison. + + +### Function `vals` +``` motoko no-repl +func vals(s : Set) : I.Iter +``` + +Returns an Iterator (`Iter`) over the elements of the set. +Iterator provides a single method `next()`, which returns +elements in ascending order, or `null` when out of elements to iterate over. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 2, 1])); + +Debug.print(debug_show(Iter.toArray(natSet.vals(set)))); +// [0, 1, 2] +``` +Cost of iteration over all elements: +Runtime: `O(n)`. +Space: `O(log(n))` retained memory plus garbage, see the note below. +where `n` denotes the number of elements stored in the set. + +Note: Full set iteration creates `O(n)` temporary objects that will be collected as garbage. + + +### Function `valsRev` +``` motoko no-repl +func valsRev(s : Set) : I.Iter +``` + +Same as `vals()` but iterates over elements of the set `s` in the descending order. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 2, 1])); + +Debug.print(debug_show(Iter.toArray(natSet.valsRev(set)))); +// [2, 1, 0] +``` +Cost of iteration over all elements: +Runtime: `O(n)`. +Space: `O(log(n))` retained memory plus garbage, see the note below. +where `n` denotes the number of elements stored in the set. + +Note: Full set iteration creates `O(n)` temporary objects that will be collected as garbage. + + +### Function `empty` +``` motoko no-repl +func empty() : Set +``` + +Create a new empty Set. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.empty(); + +Debug.print(debug_show(natSet.size(set))); // => 0 +``` + +Cost of empty set creation +Runtime: `O(1)`. +Space: `O(1)` + + +### Function `size` +``` motoko no-repl +func size(s : Set) : Nat +``` + +Returns the number of elements in the set. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 2, 1])); + +Debug.print(debug_show(natSet.size(set))); // => 3 +``` + +Runtime: `O(1)`. +Space: `O(1)`. + + +### Function `foldLeft` +``` motoko no-repl +func foldLeft(set : Set, base : Accum, combine : (Accum, T) -> Accum) : Accum +``` + +Collapses the elements in `set` into a single value by starting with `base` +and progessively combining elements into `base` with `combine`. Iteration runs +left to right. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 2, 1])); + +func folder(accum : Nat, val : Nat) : Nat = val + accum; + +Debug.print(debug_show(natSet.foldLeft(set, 0, folder))); +// 3 +``` + +Cost of iteration over all elements: +Runtime: `O(n)`. +Space: depends on `combine` function plus garbage, see the note below. +where `n` denotes the number of elements stored in the set. + +Note: Full set iteration creates `O(n)` temporary objects that will be collected as garbage. + + +### Function `foldRight` +``` motoko no-repl +func foldRight(set : Set, base : Accum, combine : (T, Accum) -> Accum) : Accum +``` + +Collapses the elements in `set` into a single value by starting with `base` +and progessively combining elements into `base` with `combine`. Iteration runs +right to left. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 2, 1])); + +func folder(val : Nat, accum : Nat) : Nat = val + accum; + +Debug.print(debug_show(natSet.foldRight(set, 0, folder))); +// 3 +``` + +Cost of iteration over all elements: +Runtime: `O(n)`. +Space: depends on `combine` function plus garbage, see the note below. +where `n` denotes the number of elements stored in the set. + +Note: Full set iteration creates `O(n)` temporary objects that will be collected as garbage. + + +### Function `isEmpty` +``` motoko no-repl +func isEmpty(s : Set) : Bool +``` + +Test if the given set `s` is empty. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.empty(); + +Debug.print(debug_show(natSet.isEmpty(set))); // => true +``` + +Runtime: `O(1)`. +Space: `O(1)`. + + +### Function `all` +``` motoko no-repl +func all(s : Set, pred : T -> Bool) : Bool +``` + +Test whether all values in the set `s` satisfy a given predicate `pred`. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 2, 1])); + +Debug.print(debug_show(natSet.all(set, func (v) = (v < 10)))); +// true +Debug.print(debug_show(natSet.all(set, func (v) = (v < 2)))); +// false +``` + +Runtime: `O(n)`. +Space: `O(1)`. +where `n` denotes the number of elements stored in the set. + + +### Function `some` +``` motoko no-repl +func some(s : Set, pred : (T) -> Bool) : Bool +``` + +Test if there exists an element in the set `s` satisfying the given predicate `pred`. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; +import Iter "mo:base/Iter"; +import Debug "mo:base/Debug"; + +let natSet = Set.Make(Nat.compare); +let set = natSet.fromIter(Iter.fromArray([0, 2, 1])); + +Debug.print(debug_show(natSet.some(set, func (v) = (v >= 3)))); +// false +Debug.print(debug_show(natSet.some(set, func (v) = (v >= 0)))); +// true +``` + +Runtime: `O(n)`. +Space: `O(1)`. +where `n` denotes the number of elements stored in the set. + + +### Function `validate` +``` motoko no-repl +func validate(s : Set) : () +``` + +Test helper that check internal invariant for the given set `s`. +Raise an error (for a stack trace) if invariants are violated. + +## Value `Make` +``` motoko no-repl +let Make : (compare : (T, T) -> O.Order) -> Operations +``` + +Create `OrderedSet.Operations` object capturing element type `T` and `compare` function. +It is an alias for the `Operations` constructor. + +Example: +```motoko +import Set "mo:base/OrderedSet"; +import Nat "mo:base/Nat"; + +actor { + let natSet = Set.Make(Nat.compare); + stable var set : Set.Set = natSet.empty(); +}; +``` diff --git a/doc/md/base/Principal.md b/doc/md/base/Principal.md index 0972518a09f..2a522beeec0 100644 --- a/doc/md/base/Principal.md +++ b/doc/md/base/Principal.md @@ -47,6 +47,20 @@ actor MyCanister { } ``` +## Function `toLedgerAccount` +``` motoko no-repl +func toLedgerAccount(principal : Principal, subAccount : ?Blob) : Blob +``` + +Compute the Ledger account identifier of a principal. Optionally specify a sub-account. + +Example: +```motoko include=import +let principal = Principal.fromText("un4fu-tqaaa-aaaab-qadjq-cai"); +let subAccount : Blob = "\4A\8D\3F\2B\6E\01\C8\7D\9E\03\B4\56\7C\F8\9A\01\D2\34\56\78\9A\BC\DE\F0\12\34\56\78\9A\BC\DE\F0"; +let account = Principal.toLedgerAccount(principal, ?subAccount); // => \8C\5C\20\C6\15\3F\7F\51\E2\0D\0F\0F\B5\08\51\5B\47\65\63\A9\62\B4\A9\91\5F\4F\02\70\8A\ED\4F\82 +``` + ## Function `toBlob` ``` motoko no-repl func toBlob(p : Principal) : Blob @@ -113,6 +127,19 @@ let principal = Principal.fromText("un4fu-tqaaa-aaaab-qadjq-cai"); Principal.isAnonymous(principal) // => false ``` +## Function `isController` +``` motoko no-repl +func isController(p : Principal) : Bool +``` + +Checks if the given principal can control this canister. + +Example: +```motoko include=import +let principal = Principal.fromText("un4fu-tqaaa-aaaab-qadjq-cai"); +Principal.isController(principal) // => false +``` + ## Function `hash` ``` motoko no-repl func hash(principal : Principal) : Hash.Hash diff --git a/doc/md/base/RBTree.md b/doc/md/base/RBTree.md index cc23c2eb76f..c767a247325 100644 --- a/doc/md/base/RBTree.md +++ b/doc/md/base/RBTree.md @@ -26,11 +26,12 @@ for (entry in tree.entries()) { Performance: * Runtime: `O(log(n))` worst case cost per insertion, removal, and retrieval operation. -* Space: `O(n)` for storing the entire tree. +* Heap space: `O(n)` for storing the entire tree. +* Stack space: `O(log(n)) for storing the entire tree. `n` denotes the number of key-value entries (i.e. nodes) stored in the tree. Note: -* Tree operations, such as retrieval, insertion, and removal create `O(log(n))` temporary objects that become garbage. +* Tree insertion, replacement, and removal produce `O(log(n))` garbage objects. Credits: @@ -80,7 +81,8 @@ let tree = RBTree.RBTree(Nat.compare); // Create a map of `Nat` to `T Costs of instantiation (only empty tree): Runtime: `O(1)`. -Space: `O(1)`. +Heap space: `O(1)`. +Stack space: `O(1)`. ### Function `share` ``` motoko no-repl @@ -104,7 +106,8 @@ Useful for storing the state of a tree object as a stable variable, determining i.e. passing it in async arguments or async results. Runtime: `O(1)`. -Space: `O(1)`. +Heap space: `O(1)`. +Stack space: `O(1)`. ### Function `unshare` @@ -128,7 +131,8 @@ Iter.toArray(tree.entries()) // => [(1, "one")] Useful for restoring the state of a tree object from stable data, saved, for example, in a stable variable. Runtime: `O(1)`. -Space: `O(1)`. +Heap space: `O(1)`. +Stack space: `O(1)`. ### Function `get` @@ -149,12 +153,11 @@ tree.get(1) // => ?"one" ``` Runtime: `O(log(n))`. -Space: `O(1)` retained memory plus garbage, see the note below. +Heap space: `O(1)`. +Stack space: `O(log(n))`. where `n` denotes the number of key-value entries stored in the tree and assuming that the `compare` function implements an `O(1)` comparison. -Note: Creates `O(log(n))` temporary objects that will be collected as garbage. - ### Function `replace` ``` motoko no-repl @@ -179,11 +182,12 @@ Iter.toArray(tree.entries()) // => [(1, "new one"), (2, "two")] ``` Runtime: `O(log(n))`. -Space: `O(1)` retained memory plus garbage, see the note below. +Heap space: `O(1)` retained memory plus garbage, see the note below. +Stack space: `O(log(n))`. where `n` denotes the number of key-value entries stored in the tree and assuming that the `compare` function implements an `O(1)` comparison. -Note: Creates `O(log(n))` temporary objects that will be collected as garbage. +Note: Creates `O(log(n))` garbage objects. ### Function `put` @@ -204,11 +208,12 @@ Iter.toArray(tree.entries()) // now contains three entries ``` Runtime: `O(log(n))`. -Space: `O(1)` retained memory plus garbage, see the note below. +Heap space: `O(1)` retained memory plus garbage, see the note below. +Stack space: `O(log(n))`. where `n` denotes the number of key-value entries stored in the tree and assuming that the `compare` function implements an `O(1)` comparison. -Note: Creates `O(log(n))` temporary objects that will be collected as garbage. +Note: Creates `O(log(n))` garbage objects. ### Function `delete` @@ -232,7 +237,8 @@ Iter.toArray(tree.entries()) // => [(2, "two")]. ``` Runtime: `O(log(n))`. -Space: `O(1)` retained memory plus garbage, see the note below. +Heap space: `O(1)` retained memory plus garbage, see the note below. +Stack space: `O(log(n))`. where `n` denotes the number of key-value entries stored in the tree and assuming that the `compare` function implements an `O(1)` comparison. @@ -259,11 +265,12 @@ Iter.toArray(tree.entries()) // => [(2, "two")]. ``` Runtime: `O(log(n))`. -Space: `O(1)` retained memory plus garbage, see the note below. +Heap space: `O(1)` retained memory plus garbage, see the note below. +Stack space: `O(log(n))`. where `n` denotes the number of key-value entries stored in the tree and assuming that the `compare` function implements an `O(1)` comparison. -Note: Creates `O(log(n))` temporary objects that will be collected as garbage. +Note: Creates `O(log(n))` garbage objects. ### Function `entries` @@ -293,7 +300,8 @@ for (entry in tree.entries()) { Cost of iteration over all elements: Runtime: `O(n)`. -Space: `O(log(n))` retained memory plus garbage, see the note below. +Heap space: `O(log(n))` retained memory plus garbage, see the note below. +Stack space: `O(log(n))`. where `n` denotes the number of key-value entries stored in the tree. Note: Full tree iteration creates `O(n)` temporary objects that will be collected as garbage. @@ -327,7 +335,8 @@ for (entry in tree.entriesRev()) { Cost of iteration over all elements: Runtime: `O(n)`. -Space: `O(log(n))` retained memory plus garbage, see the note below. +Heap space: `O(log(n))` retained memory plus garbage, see the note below. +Stack space: `O(log(n))`. where `n` denotes the number of key-value entries stored in the tree. Note: Full tree iteration creates `O(n)` temporary objects that will be collected as garbage. @@ -362,7 +371,8 @@ for (entry in RBTree.iter(tree.share(), #bwd)) { // backward iteration Cost of iteration over all elements: Runtime: `O(n)`. -Space: `O(log(n))` retained memory plus garbage, see the note below. +Heap space: `O(log(n))` retained memory plus garbage, see the note below. +Stack space: `O(log(n))`. where `n` denotes the number of key-value entries stored in the tree. Note: Full tree iteration creates `O(n)` temporary objects that will be collected as garbage. @@ -388,7 +398,6 @@ RBTree.size(tree.share()) // 3 entries ``` Runtime: `O(log(n))`. -Space: `O(1)` retained memory plus garbage, see the note below. +Heap space: `O(1)`. +Stack space: `O(log(n))`. where `n` denotes the number of key-value entries stored in the tree. - -Note: Creates `O(log(n))` temporary objects that will be collected as garbage. diff --git a/doc/md/base/Region.md b/doc/md/base/Region.md new file mode 100644 index 00000000000..dfe7e780cdd --- /dev/null +++ b/doc/md/base/Region.md @@ -0,0 +1,483 @@ +# Region +Byte-level access to isolated, (virtual) stable memory _regions_. + +This is a moderately lightweight abstraction over IC _stable memory_ and supports persisting +regions of binary data across Motoko upgrades. +Use of this module is fully compatible with Motoko's use of +_stable variables_, whose persistence mechanism also uses (real) IC stable memory internally, but does not interfere with this API. +It is also fully compatible with existing uses of the `ExperimentalStableMemory` library, which has a similar interface, but, +only supported a single memory region, without isolation between different applications. + +The `Region` type is stable and can be used in stable data structures. + +A new, empty `Region` is allocated using function `new()`. + +Regions are stateful objects and can be distinguished by the numeric identifier returned by function `id(region)`. +Every region owns an initially empty, but growable sequence of virtual IC stable memory pages. +The current size, in pages, of a region is returned by function `size(region)`. +The size of a region determines the range, [ 0, ..., size(region)*2^16 ), of valid byte-offsets into the region; these offsets are used as the source and destination of `load`/`store` operations on the region. + +Memory is allocated to a region, using function `grow(region, pages)`, sequentially and on demand, in units of 64KiB logical pages, starting with 0 allocated pages. +A call to `grow` may succeed, returning the previous size of the region, or fail, returning a sentinel value. New pages are zero initialized. + +A size of a region can only grow and never shrink. +In addition, the stable memory pages allocated to a region will *not* be reclaimed by garbage collection, even +if the region object itself becomes unreachable. + +Growth is capped by a soft limit on physical page count controlled by compile-time flag +`--max-stable-pages ` (the default is 65536, or 4GiB). + +Each `load` operation loads from region relative byte address `offset` in little-endian +format using the natural bit-width of the type in question. +The operation traps if attempting to read beyond the current region size. + +Each `store` operation stores to region relative byte address `offset` in little-endian format using the natural bit-width of the type in question. +The operation traps if attempting to write beyond the current region size. + +Text values can be handled by using `Text.decodeUtf8` and `Text.encodeUtf8`, in conjunction with `loadBlob` and `storeBlob`. + +The current region allocation and region contents are preserved across upgrades. + +NB: The IC's actual stable memory size (`ic0.stable_size`) may exceed the +total page size reported by summing all regions sizes. +This (and the cap on growth) are to accommodate Motoko's stable variables and bookkeeping for regions. +Applications that plan to use Motoko stable variables sparingly or not at all can +increase `--max-stable-pages` as desired, approaching the IC maximum (initially 8GiB, then 32Gib, currently 64Gib). +All applications should reserve at least one page for stable variable data, even when no stable variables are used. + +Usage: +```motoko no-repl +import Region "mo:base/Region"; +``` + +## Type `Region` +``` motoko no-repl +type Region = Prim.Types.Region +``` + +A stateful handle to an isolated region of IC stable memory. +`Region` is a stable type and regions can be stored in stable variables. + +## Value `new` +``` motoko no-repl +let new : () -> Region +``` + +Allocate a new, isolated Region of size 0. + +Example: + +```motoko no-repl +let region = Region.new(); +assert Region.size(region) == 0; +``` + +## Value `id` +``` motoko no-repl +let id : Region -> Nat +``` + +Return a Nat identifying the given region. +Maybe be used for equality, comparison and hashing. +NB: Regions returned by `new()` are numbered from 16 +(regions 0..15 are currently reserved for internal use). +Allocate a new, isolated Region of size 0. + +Example: + +```motoko no-repl +let region = Region.new(); +assert Region.id(region) == 16; +``` + +## Value `size` +``` motoko no-repl +let size : (region : Region) -> (pages : Nat64) +``` + +Current size of `region`, in pages. +Each page is 64KiB (65536 bytes). +Initially `0`. +Preserved across upgrades, together with contents of allocated +stable memory. + +Example: +```motoko no-repl +let region = Region.new(); +let beforeSize = Region.size(region); +ignore Region.grow(region, 10); +let afterSize = Region.size(region); +afterSize - beforeSize // => 10 +``` + +## Value `grow` +``` motoko no-repl +let grow : (region : Region, newPages : Nat64) -> (oldPages : Nat64) +``` + +Grow current `size` of `region` by the given number of pages. +Each page is 64KiB (65536 bytes). +Returns the previous `size` when able to grow. +Returns `0xFFFF_FFFF_FFFF_FFFF` if remaining pages insufficient. +Every new page is zero-initialized, containing byte 0x00 at every offset. +Function `grow` is capped by a soft limit on `size` controlled by compile-time flag + `--max-stable-pages ` (the default is 65536, or 4GiB). + +Example: +```motoko no-repl +import Error "mo:base/Error"; + +let region = Region.new(); +let beforeSize = Region.grow(region, 10); +if (beforeSize == 0xFFFF_FFFF_FFFF_FFFF) { + throw Error.reject("Out of memory"); +}; +let afterSize = Region.size(region); +afterSize - beforeSize // => 10 +``` + +## Value `loadNat8` +``` motoko no-repl +let loadNat8 : (region : Region, offset : Nat64) -> Nat8 +``` + +Within `region`, load a `Nat8` value from `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeNat8(region, offset, value); +Region.loadNat8(region, offset) // => 123 +``` + +## Value `storeNat8` +``` motoko no-repl +let storeNat8 : (region : Region, offset : Nat64, value : Nat8) -> () +``` + +Within `region`, store a `Nat8` value at `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeNat8(region, offset, value); +Region.loadNat8(region, offset) // => 123 +``` + +## Value `loadNat16` +``` motoko no-repl +let loadNat16 : (region : Region, offset : Nat64) -> Nat16 +``` + +Within `region`, load a `Nat16` value from `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeNat16(region, offset, value); +Region.loadNat16(region, offset) // => 123 +``` + +## Value `storeNat16` +``` motoko no-repl +let storeNat16 : (region : Region, offset : Nat64, value : Nat16) -> () +``` + +Within `region`, store a `Nat16` value at `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeNat16(region, offset, value); +Region.loadNat16(region, offset) // => 123 +``` + +## Value `loadNat32` +``` motoko no-repl +let loadNat32 : (region : Region, offset : Nat64) -> Nat32 +``` + +Within `region`, load a `Nat32` value from `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeNat32(region, offset, value); +Region.loadNat32(region, offset) // => 123 +``` + +## Value `storeNat32` +``` motoko no-repl +let storeNat32 : (region : Region, offset : Nat64, value : Nat32) -> () +``` + +Within `region`, store a `Nat32` value at `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeNat32(region, offset, value); +Region.loadNat32(region, offset) // => 123 +``` + +## Value `loadNat64` +``` motoko no-repl +let loadNat64 : (region : Region, offset : Nat64) -> Nat64 +``` + +Within `region`, load a `Nat64` value from `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeNat64(region, offset, value); +Region.loadNat64(region, offset) // => 123 +``` + +## Value `storeNat64` +``` motoko no-repl +let storeNat64 : (region : Region, offset : Nat64, value : Nat64) -> () +``` + +Within `region`, store a `Nat64` value at `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeNat64(region, offset, value); +Region.loadNat64(region, offset) // => 123 +``` + +## Value `loadInt8` +``` motoko no-repl +let loadInt8 : (region : Region, offset : Nat64) -> Int8 +``` + +Within `region`, load a `Int8` value from `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeInt8(region, offset, value); +Region.loadInt8(region, offset) // => 123 +``` + +## Value `storeInt8` +``` motoko no-repl +let storeInt8 : (region : Region, offset : Nat64, value : Int8) -> () +``` + +Within `region`, store a `Int8` value at `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeInt8(region, offset, value); +Region.loadInt8(region, offset) // => 123 +``` + +## Value `loadInt16` +``` motoko no-repl +let loadInt16 : (region : Region, offset : Nat64) -> Int16 +``` + +Within `region`, load a `Int16` value from `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeInt16(region, offset, value); +Region.loadInt16(region, offset) // => 123 +``` + +## Value `storeInt16` +``` motoko no-repl +let storeInt16 : (region : Region, offset : Nat64, value : Int16) -> () +``` + +Within `region`, store a `Int16` value at `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeInt16(region, offset, value); +Region.loadInt16(region, offset) // => 123 +``` + +## Value `loadInt32` +``` motoko no-repl +let loadInt32 : (region : Region, offset : Nat64) -> Int32 +``` + +Within `region`, load a `Int32` value from `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeInt32(region, offset, value); +Region.loadInt32(region, offset) // => 123 +``` + +## Value `storeInt32` +``` motoko no-repl +let storeInt32 : (region : Region, offset : Nat64, value : Int32) -> () +``` + +Within `region`, store a `Int32` value at `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeInt32(region, offset, value); +Region.loadInt32(region, offset) // => 123 +``` + +## Value `loadInt64` +``` motoko no-repl +let loadInt64 : (region : Region, offset : Nat64) -> Int64 +``` + +Within `region`, load a `Int64` value from `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeInt64(region, offset, value); +Region.loadInt64(region, offset) // => 123 +``` + +## Value `storeInt64` +``` motoko no-repl +let storeInt64 : (region : Region, offset : Nat64, value : Int64) -> () +``` + +Within `region`, store a `Int64` value at `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 123; +Region.storeInt64(region, offset, value); +Region.loadInt64(region, offset) // => 123 +``` + +## Value `loadFloat` +``` motoko no-repl +let loadFloat : (region : Region, offset : Nat64) -> Float +``` + +Within `region`, loads a `Float` value from the given `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 1.25; +Region.storeFloat(region, offset, value); +Region.loadFloat(region, offset) // => 1.25 +``` + +## Value `storeFloat` +``` motoko no-repl +let storeFloat : (region : Region, offset : Nat64, value : Float) -> () +``` + +Within `region`, store float `value` at the given `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +let region = Region.new(); +let offset = 0; +let value = 1.25; +Region.storeFloat(region, offset, value); +Region.loadFloat(region, offset) // => 1.25 +``` + +## Value `loadBlob` +``` motoko no-repl +let loadBlob : (region : Region, offset : Nat64, size : Nat) -> Blob +``` + +Within `region,` load `size` bytes starting from `offset` as a `Blob`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +import Blob "mo:base/Blob"; + +let region = Region.new(); +let offset = 0; +let value = Blob.fromArray([1, 2, 3]); +let size = value.size(); +Region.storeBlob(region, offset, value); +Blob.toArray(Region.loadBlob(region, offset, size)) // => [1, 2, 3] +``` + +## Value `storeBlob` +``` motoko no-repl +let storeBlob : (region : Region, offset : Nat64, value : Blob) -> () +``` + +Within `region, write `blob.size()` bytes of `blob` beginning at `offset`. +Traps on an out-of-bounds access. + +Example: +```motoko no-repl +import Blob "mo:base/Blob"; + +let region = Region.new(); +let offset = 0; +let value = Blob.fromArray([1, 2, 3]); +let size = value.size(); +Region.storeBlob(region, offset, value); +Blob.toArray(Region.loadBlob(region, offset, size)) // => [1, 2, 3] +``` diff --git a/doc/md/base/Result.md b/doc/md/base/Result.md index 94771d6173a..0980994b2e4 100644 --- a/doc/md/base/Result.md +++ b/doc/md/base/Result.md @@ -151,3 +151,21 @@ func assertErr(r : Result) ``` Asserts that its argument is an `#err` result, traps otherwise. + +## Function `fromUpper` +``` motoko no-repl +func fromUpper(result : {#Ok : Ok; #Err : Err}) : Result +``` + +Converts an upper cased `#Ok`, `#Err` result type into a lowercased `#ok`, `#err` result type. +On the IC, a common convention is to use `#Ok` and `#Err` as the variants of a result type, +but in Motoko, we use `#ok` and `#err` instead. + +## Function `toUpper` +``` motoko no-repl +func toUpper(result : Result) : {#Ok : Ok; #Err : Err} +``` + +Converts a lower cased `#ok`, `#err` result type into an upper cased `#Ok`, `#Err` result type. +On the IC, a common convention is to use `#Ok` and `#Err` as the variants of a result type, +but in Motoko, we use `#ok` and `#err` instead. diff --git a/doc/md/base/Text.md b/doc/md/base/Text.md index 82e9024f163..ef7e9e8c764 100644 --- a/doc/md/base/Text.md +++ b/doc/md/base/Text.md @@ -62,6 +62,38 @@ for (c in Text.toIter("abc")) { } ``` +## Function `toArray` +``` motoko no-repl +func toArray(t : Text) : [Char] +``` + +Creates a new `Array` containing characters of the given `Text`. + +Equivalent to `Iter.toArray(t.chars())`. + +```motoko include=import +assert Text.toArray("Café") == ['C', 'a', 'f', 'é']; +``` + +Runtime: O(t.size()) +Space: O(t.size()) + +## Function `toVarArray` +``` motoko no-repl +func toVarArray(t : Text) : [var Char] +``` + +Creates a new mutable `Array` containing characters of the given `Text`. + +Equivalent to `Iter.toArrayMut(t.chars())`. + +```motoko include=import +assert Text.toVarArray("Café") == [var 'C', 'a', 'f', 'é']; +``` + +Runtime: O(t.size()) +Space: O(t.size()) + ## Function `fromIter` ``` motoko no-repl func fromIter(cs : Iter.Iter) : Text @@ -403,3 +435,27 @@ Returns `null` if the blob is not valid UTF-8. ```motoko include=import let text = Text.decodeUtf8("\48\65\6C\6C\6F"); // ?"Hello" ``` + +## Value `toLowercase` +``` motoko no-repl +let toLowercase : Text -> Text +``` + +Returns the text argument in lowercase. +WARNING: Unicode compliant only when compiled, not interpreted. + +```motoko include=import +let text = Text.toLowercase("Good Day"); // ?"good day" +``` + +## Value `toUppercase` +``` motoko no-repl +let toUppercase : Text -> Text +``` + +Returns the text argument in uppercase. Unicode compliant. +WARNING: Unicode compliant only when compiled, not interpreted. + +```motoko include=import +let text = Text.toUppercase("Good Day"); // ?"GOOD DAY" +``` diff --git a/doc/md/base/Trie.md b/doc/md/base/Trie.md index dd84a19dcfa..35311067f0c 100644 --- a/doc/md/base/Trie.md +++ b/doc/md/base/Trie.md @@ -1,15 +1,8 @@ # Trie Functional key-value hash maps. -Functional maps (and sets) whose representation is "canonical", and -independent of operation history (unlike other popular search trees). - -The representation we use here comes from Section 6 of ["Incremental computation via function caching", Pugh & Teitelbaum](https://dl.acm.org/citation.cfm?id=75305). - -## User's overview - -This module provides an applicative (functional) hash map. -Notably, each `put` produces a **new trie _and value being replaced, if any_**. +This module provides an applicative (functional) hash map, called a trie. +Notably, each operation produces a new trie rather than destructively updating an existing trie. Those looking for a more familiar (imperative, object-oriented) hash map should consider `TrieMap` or `HashMap` instead. @@ -23,6 +16,12 @@ The basic `Trie` operations consist of: The `put`, `get` and `remove` operations work over `Key` records, which group the hash of the key with its non-hash key value. +LIMITATIONS: This data structure allows at most MAX_LEAF_SIZE=8 hash collisions: +attempts to insert more than MAX_LEAF_SIZE keys (whether directly via `put` or indirectly via other operations) with the same hash value will trap. + +CREDITS: Based on Section 6 of ["Incremental computation via function caching", Pugh & Teitelbaum](https://dl.acm.org/citation.cfm?id=75305). + + Example: ```motoko import Trie "mo:base/Trie"; @@ -122,8 +121,8 @@ type Branch = { size : Nat; left : Trie; right : Trie } ``` Branch nodes of the trie discriminate on a bit position of the keys' hashes. -we never store this bitpos; rather, -we enforce a style where this position is always known from context. +This bit position is not stored in the branch but determined from +the context of the branch. ## Type `AssocList` ``` motoko no-repl @@ -546,7 +545,7 @@ Build sequence of two sub-builds ### Function `prod` ``` motoko no-repl -func prod(tl : Trie, tr : Trie, op : (K1, V1, K2, V2) -> ?(K3, V3), k3_eq : (K3, K3) -> Bool) : Build +func prod(tl : Trie, tr : Trie, op : (K1, V1, K2, V2) -> ?(K3, V3), _k3_eq : (K3, K3) -> Bool) : Build ``` Like [`prod`](#prod), except do not actually do the put calls, just @@ -920,7 +919,7 @@ new trie, and the prior value, if any. ## Function `mergeDisjoint2D` ``` motoko no-repl -func mergeDisjoint2D(t : Trie2D, k1_eq : (K1, K1) -> Bool, k2_eq : (K2, K2) -> Bool) : Trie +func mergeDisjoint2D(t : Trie2D, _k1_eq : (K1, K1) -> Bool, k2_eq : (K2, K2) -> Bool) : Trie ``` Like [`mergeDisjoint`](#mergedisjoint), except instead of merging a diff --git a/doc/md/base/TrieMap.md b/doc/md/base/TrieMap.md index c84508aab4c..65c7e97f0ca 100644 --- a/doc/md/base/TrieMap.md +++ b/doc/md/base/TrieMap.md @@ -4,6 +4,11 @@ The class wraps and manipulates an underyling hash trie, found in the `Trie` module. The trie is a binary tree in which the position of elements in the tree are determined using the hash of the elements. +LIMITATIONS: This data structure allows at most MAX_LEAF_SIZE=8 hash collisions: +attempts to insert more than MAX_LEAF_SIZE keys (whether directly via `put` or indirectly via other operations) with the same hash value will trap. +This limitation is inherited from the underlying `Trie` data structure. + + Note: The `class` `TrieMap` exposes the same interface as `HashMap`. Creating a map: diff --git a/doc/md/base/TrieSet.md b/doc/md/base/TrieSet.md index 949c1a74ede..2d4279108b7 100644 --- a/doc/md/base/TrieSet.md +++ b/doc/md/base/TrieSet.md @@ -4,6 +4,10 @@ Functional set Sets are partial maps from element type to unit type, i.e., the partial map represents the set with its domain. +LIMITATIONS: This data structure allows at most MAX_LEAF_SIZE=8 hash collisions: +attempts to insert more than MAX_LEAF_SIZE elements (whether directly via `put` or indirectly via other operations) with the same hash value will trap. +This limitation is inherited from the underlying `Trie` data structure. + ## Type `Hash` ``` motoko no-repl type Hash = Hash.Hash @@ -70,6 +74,15 @@ Test if `s1` is a subset of `s2`. func mem(s : Set, x : T, xh : Hash, eq : (T, T) -> Bool) : Bool ``` +@deprecated: use `TrieSet.contains()` + +Test if a set contains a given element. + +## Function `contains` +``` motoko no-repl +func contains(s : Set, x : T, xh : Hash, eq : (T, T) -> Bool) : Bool +``` + Test if a set contains a given element. ## Function `union` diff --git a/doc/md/base/_category_.yml b/doc/md/base/_category_.yml new file mode 100644 index 00000000000..d67107b1055 --- /dev/null +++ b/doc/md/base/_category_.yml @@ -0,0 +1,5 @@ +position: 9 +label: 'Motoko base library' +collapsible: true # make the category collapsible +collapsed: true + diff --git a/doc/md/base/index.md b/doc/md/base/index.md index fe309f94892..0807634109a 100644 --- a/doc/md/base/index.md +++ b/doc/md/base/index.md @@ -19,25 +19,28 @@ * [HashMap](HashMap.md) Class `HashMap` provides a hashmap from keys of type `K` to values of type `V`. * [Heap](Heap.md) Class `Heap` provides a priority queue of elements of type `X`. * [Int](Int.md) Signed integer numbers with infinite precision (also called big integers). -* [Int16](Int16.md) 16-bit signed integers with checked arithmetic. -* [Int32](Int32.md) 32-bit signed integers with checked arithmetic. -* [Int64](Int64.md) 64-bit signed integers with checked arithmetic. -* [Int8](Int8.md) 8-bit signed integers with checked arithmetic. +* [Int16](Int16.md) Provides utility functions on 16-bit signed integers. +* [Int32](Int32.md) Provides utility functions on 32-bit signed integers. +* [Int64](Int64.md) Provides utility functions on 64-bit signed integers. +* [Int8](Int8.md) Provides utility functions on 8-bit signed integers. * [Iter](Iter.md) Iterators * [IterType](IterType.md) The Iterator type * [List](List.md) Purely-functional, singly-linked lists. * [Nat](Nat.md) Natural numbers with infinite precision. -* [Nat16](Nat16.md) 16-bit unsigned integers with checked arithmetic -* [Nat32](Nat32.md) 32-bit unsigned integers with checked arithmetic -* [Nat64](Nat64.md) 64-bit unsigned integers with checked arithmetic -* [Nat8](Nat8.md) 8-bit unsigned integers with checked arithmetic +* [Nat16](Nat16.md) Provides utility functions on 16-bit unsigned integers. +* [Nat32](Nat32.md) Provides utility functions on 32-bit unsigned integers. +* [Nat64](Nat64.md) Provides utility functions on 64-bit unsigned integers. +* [Nat8](Nat8.md) Provides utility functions on 8-bit unsigned integers. * [None](None.md) The absent value * [Option](Option.md) Typesafe nulls * [Order](Order.md) Order +* [OrderedMap](OrderedMap.md) Stable key-value map implemented as a red-black tree with nodes storing key-value pairs. +* [OrderedSet](OrderedSet.md) Stable ordered set implemented as a red-black tree. * [Prelude](Prelude.md) General utilities * [Principal](Principal.md) Module for interacting with Principals (users and canisters). * [RBTree](RBTree.md) Key-value map implemented as a red-black tree (RBTree) with nodes storing key-value pairs. * [Random](Random.md) A module for obtaining randomness on the Internet Computer (IC). +* [Region](Region.md) Byte-level access to isolated, (virtual) stable memory _regions_. * [Result](Result.md) Error handling with the Result type. * [Stack](Stack.md) Class `Stack` provides a Minimal LIFO stack of elements of type `X`. * [Text](Text.md) Utility functions for `Text` values. diff --git a/doc/md/basic-concepts.md b/doc/md/basic-concepts.md deleted file mode 100644 index c31ab5890f1..00000000000 --- a/doc/md/basic-concepts.md +++ /dev/null @@ -1,505 +0,0 @@ -# Basic concepts and terms - -Motoko is designed for distributed programming with actors. - -When programming on the Internet Computer in Motoko, each **actor** represents an **Internet Computer canister smart contract** with a Candid interface, whether written in Motoko, Rust, Wasm or some other language that compiles to Wasm. Within Motoko, we use the term **actor** to refer to any canister, authored in any language that deploys to the Internet Computer. The role of Motoko is to make these actors easy to author, and easy to use programmatically, once deployed. - -Before you begin writing distributed applications using actors, you should be familiar with a few of the basic building blocks of any programming language and with Motoko in particular. To get you started, this section introduces the following key concepts and terms that are used throughout the remainder of the documentation and that are essential to learning to program in Motoko: - -- program - -- declaration - -- expression - -- value - -- variable - -- type - -If you have experience programming in other languages or are familiar with modern programming language theory, you are probably already comfortable with these terms and how they are used. There’s nothing unique in how these terms are used in Motoko. If you are new to programming, however, this guide introduces each of these terms gradually and by using simplified example programs that eschew any use of actors or distributed programming. After you have the basic terminology as a foundation to build on, you can explore more advanced aspects of the language. More advanced features are illustrated with correspondingly more complex examples. - -The following topics are covered in the section: - -- [Motoko program syntax](#motoko-program-syntax) - -- [Printing values](#printing-values) - -- [Using the base library](#the-motoko-base-library) - -- [Declarations versus expressions](#declarations-versus-expressions) - -- [Lexical scoping of variables](#declarations-follow-lexical-scoping) - -- [Values and evaluation](#values-and-evaluation) - -- [Type annotations and variables](#type-annotations-and-variables) - -- [Type soundness and type-safe evaluation](#type-soundness) - -## Motoko program syntax - -Each Motoko *program* is a free mix of declarations and expressions, whose syntactic classes are distinct, but related (see the [language quick reference](language-manual.md) for precise program syntax). - -For programs that we deploy on the Internet Computer, a valid program consists of an *actor expression*, introduced with specific syntax (keyword `actor`) that we discuss in [Actors and async data](actors-async.md). - -In preparing for that discussion, this section and Section [Mutable state](mutable-state.md) begin by discussing programs that are not meant to be Internet Computer services. Rather, these tiny programs illustrate snippets of Motoko for writing those services, and each can (usually) be run on its own as a (non-service) Motoko program, possibly with some printed terminal output. - -The examples in this section illustrate basic principles using simple expressions, such as arithmetic. For an overview of the full expression syntax of Motoko, see the [Language quick reference](language-manual.md). - -As a starting point, the following code snippet consists of two declarations — for the variables `x` and `y` — followed by an expression to form a single program: - -``` motoko -let x = 1; -let y = x + 1; -x * y + x; -``` - -We will use variations of this small program in our discussion below. - -First, this program’s type is `Nat` (natural number), and when run, it evaluates to the (natural number) value of `3`. - -Introducing a block with enclosing braces (`do {` and `}`) and another variable (`z`), we can amend our original program as follows: - -``` motoko -let z = do { - let x = 1; - let y = x + 1; - x * y + x -}; -``` - -## Declarations and expressions - -Declarations introduce immutable variables, mutable state, actors, objects, classes and other types. Expressions describe computations that involve these notions. - -For now, we use example programs that declare immutable variables, and compute simple arithmetic. - -### Declarations versus expressions - -[Recall](#motoko-program-syntax) that each Motoko *program* is a free mix of declarations and expressions, whose syntactic classes are distinct, but related. In this section, we use examples to illustrate their distinctions and accommodate their intermixing. - -Recall our example program, first introduced above: - -``` motoko -let x = 1; -let y = x + 1; -x * y + x; -``` - -In reality, this program is a *declaration list* that consists of *three* declarations: - -1. immutable variable `x`, via declaration `let x = 1;`, - -2. immutable variable `y`, via declaration `let y = x + 1;`, - -3. and an *unnamed, implicit variable* holding the final expression’s value, `x * y + x`. - -This expression `x * y + x` illustrates a more general principle: Each expression can be thought of as a declaration where necessary since the language implicitly declares an unnamed variable with that expression’s result value. - -When the expression appears as the final declaration, this expression may have any type. Here, the expression `x * y + x` has type `Nat`. - -Expressions that do not appear at the end, but rather *within* the list of declarations must have unit type `()`. - -### Ignoring non-unit-typed expressions in declaration lists - -We can always overcome this unit-type restriction by explicitly using `ignore` to ignore any unused result values. For example: - -``` motoko -let x = 1; -ignore(x + 42); -let y = x + 1; -ignore(y * 42); -x * y + x; -``` - -### Declarations and variable substitution - -Declarations can be mutually recursive, but in cases where they are not, they permit substitution semantics. (that is, replacing equals for equals, as familiar from high-school algebraic simplification). - -Recall our original example: - -``` motoko -let x = 1; -let y = x + 1; -x * y + x; -``` - -We can manually rewrite the program above by *substituting* the variables' declared values for each of their respective occurrences. - -In so doing, we produce the following expression, which is also a program: - -``` motoko -1 * (1 + 1) + 1 -``` - -This is also a valid program — of the same type and with the same behavior (result value `3`) — as the original program. - -We can also form a single expression using a block. - -### From declarations to block expressions - -Many of the programs above each consist of a list of declarations, as with this example, just above: - -``` motoko -let x = 1; -let y = x + 1; -x * y + x -``` - -A declaration list is not itself (immediately) an *expression*, so we cannot (immediately) declare another variable with its final value (`3`). - -**Block expressions.** We can form a *block expression* from this list of declarations by enclosing it with matching *curly braces*. Blocks are only allowed as sub-expressions of control flow expressions like `if`, `loop`, `case`, etc. In all other places, we use `do { …​ }` to represent block expression, to distinguish blocks from object literals. For example, `do {}` is the empty block of type `()`, while `{}` is an empty record of record type `{}`. - -``` motoko -do { - let x = 1; - let y = x + 1; - x * y + x -} -``` - -This is also program, but one where the declared variables `x` and `y` are privately scoped to the block we introduced. - -This block form preserves the autonomy of the declaration list and its *choice of variable names*. - -A block expression produces a value and, when enclosed in parentheses, can occur within some larger, compound expression. For example: - -``` motoko -100 + - (do { - let x = 1; - let y = x + 1; - x * y + x - }) -``` - -### Declarations follow **lexical scoping** - -Above, we saw that nesting blocks preserves the autonomy of each separate declaration list and its *choice of variable names*. Language theorists call this idea *lexical scoping*. It means that variables' scopes may nest, but they may not interfere as they nest. - -For instance, the following (larger, enclosing) program evaluates to `42`, *not* `2`, since the final occurrences of `x` and `y`, on the final line, refer to the *very first* definitions, *not* the later ones within the enclosed block: - -``` motoko -let x = 40; let y = 2; -ignore do { - let x = 1; - let y = x + 1; - x * y + x -}; -x + y -``` - -Other languages that lack lexical scoping may give a different meaning to this program. However, modern languages universally favor lexical scoping, the meaning given here. - -Aside from mathematical clarity, the chief practical benefit of lexical scoping is *security*, and its use in building compositionally-secure systems. Specifically, Motoko gives very strong composition properties. For example, nesting your program within a program you do not trust cannot arbitrarily redefine your variables with different meanings. - -## Values and evaluation - - - -Once a Motoko expression receives the program’s (single) thread of control, it evaluates eagerly until it reduces to a *result value*. - -In so doing, it will generally pass control to sub-expressions, and to sub-routines before it gives up control from the *ambient control stack*. - -If this expression never reaches a value form, the expression evaluates indefinitely. Later we introduce recursive functions and imperative control flow, which each permit non-termination. For now, we only consider terminating programs that result in values. - -In the material above, we focused on expressions that produced natural numbers. As a broader language overview, however, we briefly summarize the other value forms below: - -### Primitive values - -Motoko permits the following primitive value forms: - -- Boolean values (`true` and `false`). - -- Integers (…​,`-2`, `-1`, `0`, `1`, `2`, …​) - bounded and *unbounded* variants. - -- Natural numbers (`0`, `1`, `2`, …​) - bounded and *unbounded* variants. - -- Text values - strings of unicode characters. - -By default, **integers** and **natural numbers** are *unbounded* and do not overflow. Instead, they use representations that grow to accommodate any finite number. - -For practical reasons, Motoko also includes *bounded* types for integers and natural numbers, distinct from the default versions. Each bounded variant has a fixed bit-width (one of `8`, `16`, `32`, `64`) that determines the range of representable values and each carries the potential for *overflow*. Exceeding a bound is a run-time fault that causes the program to [trap](#traps-due-to-faults). - -There are no unchecked, uncaught overflows in Motoko, except in well-defined situations, for explicitly *wrapping* operations (indicated by a conventional `%` character in the operator). The language provides primitive built-ins to convert between these various number representations. - -The [language quick reference](language-manual.md) contains a complete list of [primitive types](language-manual.md#primitive-types). - -### Non-primitive values - - - -Building on the primitive values and types above, the language permits user-defined types, and each of the following non-primitive value forms and associated types: - -- [Tuples](language-manual.md#tuples), including the unit value (the "empty tuple"); - -- [Arrays](language-manual.md#arrays), with both *immutable* and *mutable* variants; - -- [Objects](language-manual.md#objects), with named, unordered fields and methods; - -- [Variants](language-manual.md#variant-types), with named constructors and optional payload values; - -- [Function values](language-manual.md#functions), including [shareable functions](sharing.md); - -- [Async values](language-manual.md#async), also known as *promises* or *futures*; - -- [Error values](language-manual.md#error-type) carry the payload of exceptions and system failures. - -We discuss the use of these forms in the next sections. - -For precise language definitions of primitive and non-primitive values, see the [language quick reference](language-manual.md). - -### The *unit* type `()` - -Motoko has no type named `void`. In many cases where readers may think of return types being “void” from using languages like Java or C++, we encourage them to think instead of the *unit type*, written `()`. - -In practical terms, like `void`, the unit value usually carries zero representation cost. - -Unlike the `void` type, there *is* a unit value, but like the `void` return value, the unit value carries no values internally, and as such, it always carries zero *information*. - -Another mathematical way to think of the unit value is as a tuple with no elements - the nullary (“zero-ary”) tuple. There is only one value with these properties, so it is mathematically unique, and thus need not be represented at runtime. - -### Natural numbers - -The members of this type consist of the usual values - `0`, `1`, `2`, …​ - but, as in mathematics, the members of `Nat` are not bound to a special maximum size. Rather, the runtime representation of these values accommodates arbitrary-sized numbers, making their "overflow" (nearly) impossible. (*nearly* because it is the same event as running out of program memory, which can always happen for some programs in extreme situations). - -Motoko permits the usual arithmetic operations one would expect. As an illustrative example, consider the following program: - -``` motoko -let x = 42 + (1 * 37) / 12: Nat -``` - -This program evaluates to the value `45`, also of type `Nat`. - -## Type soundness - -Each Motoko expression that type-checks we call *well-typed*. The *type* of a Motoko expression serves as a promise from the language to the developer about the future behavior of the program, if executed. - -First, each well-typed program will evaluate without undefined behavior. That is, the phrase **“well-typed programs don’t go wrong”** applies here. For those unfamiliar with the deeper implications of that phrase, it means that there is a precise space of meaningful (unambiguous) programs, and the type system enforces that we stay within it, and that all well-typed programs have a precise (unambiguous) meaning. - -Furthermore, the types make a precise prediction over the program’s result. If it yields control, the program will generate a *result value* that agrees with that of the original program. - -In either case, the static and dynamic views of the program are linked by and agree with the static type system. This agreement is the central principle of a static type system, and is delivered by Motoko as a core aspect of its design. - -The same type system also enforces that asynchronous interactions agree between static and dynamic views of the program, and that the resulting messages generated "under the hood" never mismatch at runtime. This agreement is similar in spirit to the caller/callee argument type and return type agreements that one ordinarily expects in a typed language. - -## Type annotations and variables - -Variables relate (static) names and (static) types with (dynamic) values that are present only at runtime. - -In this sense, Motoko types provide a form of *trusted, compiler-verified documentation* in the program source code. - -Consider this very short program: - -``` motoko -let x : Nat = 1 -``` - -In this example, the compiler infers that the expression `1` has type `Nat`, and that `x` has the same type. - -In this case, we can omit this annotation without changing the meaning of the program: - -``` motoko -let x = 1 -``` - -Except for some esoteric situations involving operator overloading, type annotations do not (typically) affect the meaning of the program as it runs. - -If they are omitted and the compiler accepts the program, as is the case above, the program has the same meaning (same *behavior*) as it did originally. - -However, sometimes type annotations are required by the compiler to infer other assumptions, and to check the program as a whole. - -When they are added and the compiler still accepts the program, we know that the added annotations are *consistent* with the existing ones. - -For instance, we can add additional (not required) annotations, and the compiler checks that all annotations and other inferred facts agree as a whole: - -``` motoko -let x : Nat = 1 : Nat -``` - -If we were to try to do something *inconsistent* with our annotation type, however, the type checker will signal an error. - -Consider this program, which is not well-typed: - -``` motoko run -let x : Text = 1 + 1 -``` - -The type annotation `Text` does not agree with the rest of the program, since the type of `1 + 1` is `Nat` and not `Text`, and these types are unrelated by subtyping. Consequently, this program is not well-typed, and the compiler will signal an error (with a message and location) and will not compile or execute it. - -## Type errors and messages - -Mathematically, the type system of Motoko is *declarative*, meaning that it exists independently of any implementation, as a concept entirely in formal logic. Likewise, the other key aspects of the language definition (for example, its execution semantics) exist outside of an implementation. - -However, to design this logical definition, to experiment with it, and to practice making mistakes, we want to interact with this type system, and to make lots of harmless mistakes along the way. - -The error messages of the *type checker* attempt to help the developer when they misunderstand or otherwise misapply the logic of the type system, which is explained indirectly in this book. - -These error messages will evolve over time, and for this reason, we will not include particular error messages in this text. Instead, we will attempt to explain each code example in its surrounding prose. - -### The Motoko base library - - - -For various practical language engineering reasons, the design of Motoko strives to minimize builtin types and operations. - -Instead, whenever possible, the Motoko base library provides the types and operations that make the language feel complete. ***However**, this base library is still under development, and is still incomplete*. - -The [Motoko Base Library](./base-intro.md) lists a *selection* of modules from the Motoko base library, focusing on core features used in the examples that are unlikely to change radically. However, all of these base library APIs will certainly change over time (to varying degrees), and in particular, they will grow in size and number. - -To import from the base library, use the `import` keyword. Give a local module name to introduce, in this example `D` for “**D**ebug”, and a URL where the `import` declaration may locate the imported module: - -``` motoko file=./examples/print.mo -``` - -In this case, we import Motoko code (not some other module form) with the `mo:` prefix. We specify the `base/` path, followed by the module’s file name `Debug.mo` minus its extension. - -### Printing values - -Above, we print the text string using the function `print` in library `Debug.mo`: - -``` motoko no-repl -print: Text -> () -``` - -The function `print` accepts a text string (of type `Text`) as input, and produces the *unit value* (of *unit type*, or `()`) as its output. - -Because unit values carry no information, all values of type unit are identical, so the `print` function doesn’t actually produce an interesting result. Instead of a result, it has a *side effect*. The function `print` has the effect of emitting the text string in a human-readable form to the output terminal. Functions that have side effects, such as emitting output, or modifying state, are often called *impure*. Functions that just return values, without further side-effects, are called *pure*. We discuss the return value (the unit value) [in detail below](#the-unit-type), and relate it to the `void` type for readers more familiar with that concept. - -Finally, we can transform most Motoko values into human-readable text strings for debugging purposes, *without* having to write those transformations by hand. - -The `debug_show` primitive permits converting a large class of values into values of type `Text`. - -For instance, we can convert a triple (of type `(Text, Nat, Text)`) into debugging text without writing a custom conversion function ourselves: - -``` motoko -import D "mo:base/Debug"; -D.print(debug_show(("hello", 42, "world"))) -``` - -Using these text transformations, we can print most Motoko data as we experiment with our programs. - -### Accommodating incomplete code - -Sometimes, in the midst of writing a program, we want to run an incomplete version, or a version where one or more execution paths are either missing or simply invalid. - -To accommodate these situations, we use the `xxx`, `nyi` and `unreachable` functions from the base `Prelude` library, explained below. Each is a simple wrapper around a more general trap mechanism [general trap mechanism](#explicit-traps), explained further below. - -### Use short-term holes - -Short-term holes are never committed to a source repository, and only ever exist in a single development session, for a developer that is still writing the program. - -Assuming that earlier, one has imported the prelude as follows: - -``` motoko name=prelude -import P "mo:base/Prelude"; -``` - -The developer can fill *any missing expression* with the following one: - -``` motoko include=prelude -P.xxx() -``` - -The result will *always* type check at compile time, and *will always* trap at run time, if and when this expression ever executes. - -### Document longer-term holes - -By convention, longer-term holes can be considered "not yet implemented" (`nyi`) features, and marked as such with a similar function from the Prelude module: - -``` motoko include=prelude -P.nyi() -``` - -### Document `unreachable` code paths - -In contrast to the situations above, sometimes code will *never* be filled, since it will *never* be evaluated, assuming the coherence of the internal logic of the programs' invariants. - -To document a code path as logically impossible, or *unreachable*, use the base library function `unreachable`: - -``` motoko include=prelude -P.unreachable() -``` - -As in the situations above, this function type-checks in all contexts, and when evaluated, traps in all contexts. - - - -### Traps due to faults - -Some errors, such as division by zero, out-of-bounds array indexing, and pattern match failure are (by design) not prevented by the type system, but instead cause dynamic faults called *traps*. - -``` motoko -1/0; // traps due to division by 0 -``` - -``` motoko -let a = ["hello", "world"]; -a[2]; // traps due to out-of-bounds indexing -``` - -``` motoko -let true = false; // pattern match failure -``` - -We say that code *traps* when its exection causes a *trap*. - -Because the meaning of execution is ill-defined after a faulting trap, execution of the code ends by aborting at the trap. - -:::note - -Traps that occur within actor messages are more subtle: they don’t abort the entire actor, but prevent that particular message from proceeding, rolling back any yet uncommitted state changes. Other messages on the actor will continue execution. - -::: - -### Explicit traps - -Occasionally it can be useful to force an unconditional trap, with a user-defined message. - -The `Debug` library provides the function `trap(t)` for this purpose, which can be used in any context. - -``` motoko -import Debug "mo:base/Debug"; - -Debug.trap("oops!"); -``` - -``` motoko -import Debug "mo:base/Debug"; - -let swear : Text = Debug.trap("oh my!"); -``` - -(The `Prelude` functions `nyi()`, `unreachable()` and `xxx()` discussed above are simple wrappers around `Debug.trap`.) - -### Assertions - -Assertions allow you to conditionally trap when some Boolean test fails to hold, but continue execution otherwise. For example, - -``` motoko -let n = 65535; -assert n % 2 == 0; // traps when n not even -``` - -``` motoko -assert false; // unconditionally traps -``` - -``` motoko -import Debug "mo:base/Debug"; - -assert 1 > 0; // never traps -Debug.print "bingo!"; -``` - -Because an assertion may succeed, and thus proceed with execution, it may only be used in context where a value of type `()` is expected. diff --git a/doc/md/caller-id.md b/doc/md/caller-id.md deleted file mode 100644 index 7f123f8f5e8..00000000000 --- a/doc/md/caller-id.md +++ /dev/null @@ -1,51 +0,0 @@ -# Principals and caller identification - -Motoko’s shared functions support a simple form of caller identification that allows you to inspect the Internet Computer **principal** associated with the caller of a function. The principal associated with a call is a value that identifies a unique user or canister smart contract. - -You can use the **principal** associated with the caller of a function to implement a basic form of *access-control* in your program. - -In Motoko, the `shared` keyword is used to declare a shared function. The shared function can also declare an optional parameter of type `{caller : Principal}`. - - - -To illustrate how to access the caller of a shared function, consider the following: - -``` motoko -shared(msg) func inc() : async () { - // ... msg.caller ... -} -``` - -In this example, the shared function `inc()` specifies a `msg` parameter, a record, and the `msg.caller` accesses the principal field of `msg`. - -The calls to the `inc()` function do not change — at each call site, the caller’s principal is provided by the system, not the user — so the principal cannot be forged or spoofed by a malicious user. - -To access the caller of an actor class constructor, you use the same (optional) syntax on the actor class declaration. For example: - -``` motoko -shared(msg) actor class Counter(init : Nat) { - // ... msg.caller ... -} -``` - -To extend this example, assume you want to restrict the `Counter` actor so it can only be modified by the installer of the `Counter`. To do this, you can record the principal that installed the actor by binding it to an `owner` variable. You can then check that the caller of each method is equal to `owner` like this: - -``` motoko file=./examples/Counters-caller.mo -``` - -In this example, the `assert (owner == msg.caller)` expression causes the functions `inc()` and `bump()` to trap if the call is unauthorized, preventing any modification of the `count` variable while the `read()` function permits any caller. - -The argument to `shared` is just a pattern, so, if you prefer, you can also rewrite the above to use pattern matching: - -``` motoko file=./examples/Counters-caller-pat.mo -``` - -:::note - -Simple actor declarations do not let you access their installer. If you need access to the installer of an actor, rewrite the actor declaration as a zero-argument actor class instead. - -::: - -Principals support equality, ordering, and hashing, so you can efficiently store principals in containers, for example, to maintain an allow or deny list. More operations on principals are available in [Principal](./base/Principal.md) base library. diff --git a/doc/md/canister-maintenance/_category_.yml b/doc/md/canister-maintenance/_category_.yml new file mode 100644 index 00000000000..36d0e1cd60f --- /dev/null +++ b/doc/md/canister-maintenance/_category_.yml @@ -0,0 +1,5 @@ +position: 3 +label: 'Canister maintenance' +collapsible: true # make the category collapsible +collapsed: true + diff --git a/doc/md/canister-maintenance/compatibility.md b/doc/md/canister-maintenance/compatibility.md new file mode 100644 index 00000000000..97d511d7821 --- /dev/null +++ b/doc/md/canister-maintenance/compatibility.md @@ -0,0 +1,282 @@ +--- +sidebar_position: 4 +--- + +# Verifying upgrade compatibility + +## Overview + +When upgrading a canister, it is important to verify that the upgrade can proceed without: + +- Introducing an incompatible change in stable declarations. +- Breaking clients due to a Candid interface change. + +`dfx` checks these properties statically before attempting the upgrade. +Moreover, with [enhanced orthogonal persistence](orthogonal-persistence/enhanced.md), Motoko rejects incompatible changes of stable declarations. + +## Upgrade example + +The following is a simple example of how to declare a stateful counter: + +``` motoko no-repl file=../examples/count-v0.mo +``` + +Importantly, in this example, when the counter is upgraded, its state is lost. +This is because actor variables are by default `flexible`, meaning they get reinitialized on an upgrade. + +To fix this, you can declare a stable variable that is retained across upgrades: + + +``` motoko no-repl file=../examples/count-v1.mo +``` + +If the variable `state` were not declared `stable`, `state` would restart from `0` on upgrade. + +## Evolving the stable declarations + +Changing counter from `Nat` to `Int` is a compatible change in stable declarations. The counter value is retained during the upgrade. + +``` motoko no-repl file=../examples/count-v2.mo +``` + +## Stable type signatures + +A stable type signature describes the stable content of a Motoko actor. +You can think of this as the interior interface of the actor, that it presents to its future upgrades. + +For example, `v1`'s stable types: + +``` motoko no-repl file=../examples/count-v1.most +``` + +An upgrade from `v1` to `v2`'s stable types consumes a [`Nat`](../base/Int.md) as an [`Int`](../base/Nat.md), which is valid because `Int <: Nat`. + +``` motoko no-repl file=../examples/count-v2.most +``` + +## Evolving the Candid interface + +In this extension of the interface, old clients remain satisfied, while new ones get extra features such as the `decrement` function and the `read` query in this example. + +``` motoko no-repl file=../examples/count-v3.mo +``` + +## Dual interface evolution + +An upgrade is safe provided that both the Candid interface and stable type signatures remain compatible: +* Each stable variable must either be newly declared, dropped, or re-declared at a supertype of its old type. +* The Candid interface evolves to a subtype. + +Consider the following four versions of the counter example: + +Version `v0` with Candid interface `v0.did` and stable type interface `v0.most`: + +``` candid file=../examples/count-v0.did +``` + +``` motoko no-repl file=../examples/count-v0.most +``` + +Version `v1` with Candid interface `v1.did` and stable type interface `v1.most`, + +``` candid file=../examples/count-v1.did +``` + +``` motoko no-repl file=../examples/count-v1.most +``` + +Version `v2` with Candid interface `v2.did` and stable type interface `v2.most`, + +``` candid file=../examples/count-v2.did +``` + +``` motoko no-repl file=../examples/count-v2.most +``` + +Version `v3` with Candid interface `v3.did` and stable type interface `v3.most`: + +``` candid file=../examples/count-v3.did +``` + +``` motoko no-repl file=../examples/count-v3.most +``` + +## Incompatible upgrade + +Let's take a look at another example where the counter's type is again changed, this time from [`Int`](../base/Int.md) to [`Nat`](../base/Float.md): + +``` motoko no-repl file=../examples/count-v4.mo +``` + +This version is neither compatible to the Candid interface nor to the stable type declarations. +- Since `Float `: Checks two `.most` files for upgrade compatibility. + +Motoko embeds `.did` and `.most` files as Wasm custom sections for use by `dfx` or other tools. + +To upgrade e.g. from `cur.wasm` to `nxt.wasm`, `dfx` checks that both the Candid interface and stable variables are compatible: + +``` +didc check nxt.did cur.did // nxt <: cur +moc --stable-compatible cur.most nxt.most // cur <<: nxt +``` + +Using the versions above, the upgrade from `v3` to `v4` fails this check: + +``` +> moc --stable-compatible v3.most v4.most +(unknown location): Compatibility error [M0170], stable variable state of previous type + var Int +cannot be consumed at new type + var Float +``` + +With [enhanced orthogonal persistence](orthogonal-persistence/enhanced.md), compatibility errors of stable variables are always detected in the runtime system and if failing, the upgrade is safely rolled back. + +:::danger +With [classical orthogonal persistence](orthogonal-persistence/classical.md), however, an upgrade attempt from `v2.wasm` to `v3.wasm` is unpredictable and may lead to partial or complete data loss if the `dfx` warning is ignored. +::: + +## Adding record fields + +A common, real-world example of an incompatible upgrade can be found [on the forum](https://forum.dfinity.org/t/questions-about-data-structures-and-migrations/822/12?u=claudio/). + +In that example, a user was attempting to add a field to the record payload of an array, by upgrading from stable type interface: + +``` motoko no-repl +actor { + type Card = { + title : Text; + }; + stable var map : [(Nat32, Card)] = [(0, { title = "TEST"})]; +}; +``` + +to *incompatible* stable type interface: + +``` motoko no-repl +actor { + type Card = { + title : Text; + description : Text; + }; + stable var map : [(Nat32, Card)] = []; +}; +``` + +### Problem + +When trying this upgrade, `dfx` issues the following warning: + +``` +Stable interface compatibility check issued an ERROR for canister ... +Upgrade will either FAIL or LOSE some stable variable data. + +(unknown location): Compatibility error [M0170], stable variable map of previous type + var [(Nat32, Card)] +cannot be consumed at new type + var [(Nat32, Card__1)] + +Do you want to proceed? yes/No +``` +It is recommended not to continue, as you will lose the state in older versions of Motoko that use [classical orthogonal persistence](orthogonal-persistence/classical.md). +Upgrading with [enhanced orthogonal persistence](orthogonal-persistence/enhanced.md) will trap and roll back, keeping the old state. + +Adding a new record field to the type of existing stable variable is not supported. The reason is simple: The upgrade would need to supply values for the new field out of thin air. In this example, the upgrade would need to conjure up some value for the `description` field of every existing `card` in `map`. Moreover, allowing adding optional fields is also a problem, as a record can be shared from various variables with different static types, some of them already declaring the added field or adding a same-named optional field with a potentially different type (and/or different semantics). + +### Solution + +To resolve this issue, an [explicit](#explicit-migration) is needed: + +1. You must keep the old variable `map` with the same structural type. However, you are allowed to change type alias name (`Card` to `OldCard`). +2. You can introduce a new variable `newMap` and copy the old state to the new one, initializing the new field as needed. +3. Then, upgrade to this new version. + +``` motoko no-repl +import Array "mo:base/Array"; + +actor { + type OldCard = { + title : Text; + }; + type NewCard = { + title : Text; + description : Text; + }; + + stable var map : [(Nat32, OldCard)] = []; + stable var newMap : [(Nat32, NewCard)] = Array.map<(Nat32, OldCard), (Nat32, NewCard)>( + map, + func(key, { title }) { (key, { title; description = "" }) }, + ); +}; +``` + +4. **After** we have successfully upgraded to this new version, we can upgrade once more to a version, that drops the old `map`. + +``` motoko no-repl +actor { + type Card = { + title : Text; + description : Text; + }; + stable var newMap : [(Nat32, Card)] = []; +}; +``` + +`dfx` will issue a warning that `map` will be dropped. + +Make sure, you have previously migrated the old state to `newMap` before applying this final reduced version. + +``` +Stable interface compatibility check issued a WARNING for canister ... +(unknown location): warning [M0169], stable variable map of previous type + var [(Nat32, OldCard)] + will be discarded. This may cause data loss. Are you sure? +``` + +Logo diff --git a/doc/md/canister-maintenance/cycles.md b/doc/md/canister-maintenance/cycles.md new file mode 100644 index 00000000000..1c05399b116 --- /dev/null +++ b/doc/md/canister-maintenance/cycles.md @@ -0,0 +1,111 @@ +--- +sidebar_position: 1 +--- + + +# Cycles + +## Overview + +Usage of a canister's resources on ICP is measured and paid for in [cycles](/docs/current/developer-docs/defi/cycles/converting_icp_tokens_into_cycles). + +In Motoko programs deployed on ICP, each actor represents a canister and has an associated balance of cycles. The ownership of cycles can be transferred between actors. Cycles are selectively sent and received through shared function calls. A caller can choose to transfer cycles with a call, and a callee can choose to accept cycles that are made available by the caller. Unless explicitly instructed, no cycles are transferred by callers or accepted by callees. + +Callees can accept all, some, or none of the available cycles up to limit determined by their actor’s current balance. Any remaining cycles are refunded to the caller. If a call traps, all its accompanying cycles are automatically refunded to the caller without loss. + +In future, we may see Motoko adopt dedicated syntax and types to support safer programming with cycles. For now, we provide a temporary way to manage cycles through a low-level imperative API provided by the [ExperimentalCycles](../base/ExperimentalCycles.md) library in package `base`. + +:::note + +This library is subject to change and likely to be replaced by more high-level support for cycles in later versions of Motoko. + +::: + +## The [`ExperimentalCycles`](../base/ExperimentalCycles.md) Library + +The [`ExperimentalCycles`](../base/ExperimentalCycles.md) library provides imperative operations for observing an actor’s current balance of cycles, transferring cycles and observing refunds. + +The library provides the following operations: + +- `func balance() : (amount : Nat)`: Returns the actor’s current balance of cycles as `amount`. Function `balance()` is stateful and may return different values after calls to `accept(n)`, calling a function after `add`ing cycles, or resuming from `await` which reflects a refund. + +- `func available() : (amount : Nat)`: Returns the currently available `amount` of cycles. This is the amount received from the current caller, minus the cumulative amount `accept`ed so far by this call. On exit from the current shared function or `async` expression via `return` or `throw` any remaining available amount is automatically refunded to the caller. + +- `func accept(amount : Nat) : (accepted : Nat)`: Transfers `amount` from `available()` to `balance()`. It returns the amount actually transferred, which may be less than requested, for example, if less is available, or if canister balance limits are reached. Requires `system` capability. + +- `func add(amount : Nat) : ()`: Indicates the additional amount of cycles to be transferred in the next remote call, i.e. evaluation of a shared function call or `async` expression. Upon the call, but not before, the total amount of units `add`ed since the last call is deducted from `balance()`. If this total exceeds `balance()`, the caller traps, aborting the call. Requires `system` capability. + +- `func refunded() : (amount : Nat)`: Reports the `amount` of cycles refunded in the last `await` of the current context, or zero if no await has occurred yet. Calling `refunded()` is solely informational and does not affect `balance()`. Instead, refunds are automatically added to the current balance, whether or not `refunded` is used to observe them. + +:::danger + +Since cycles measure computational resources spent, the value of `balance()` generally decreases from one shared function call to the next. + +The implicit register of added amounts, incremented on each `add`, is reset to zero on entry to a shared function, and after each shared function call or on resume from an await. + +::: + +### Example + +To illustrate, we will now use the [`ExperimentalCycles`](../base/ExperimentalCycles.md) library to implement a simple piggy bank program for saving cycles. + +Our piggy bank has an implicit owner, a `benefit` callback and a fixed `capacity`, all supplied at time of construction. The callback is used to transfer withdrawn amounts. + +``` motoko name=PiggyBank file=../examples/PiggyBank.mo +``` + +The owner of the bank is identified with the implicit caller of constructor `PiggyBank()`, using the shared pattern, `shared(msg)`. Field `msg.caller` is a [`Principal`](../base/Principal.md) and is stored in private variable `owner` for future reference. See [principals and caller identification](../writing-motoko/caller-id.md) for more explanation of this syntax. + +The piggy bank is initially empty, with zero current `savings`. + +Only calls from `owner` may: + +- Query the current `savings` of the piggy bank (function `getSavings()`), or + +- Withdraw amounts from the savings (function `withdraw(amount)`). + +The restriction on the caller is enforced by the statements `assert (msg.caller == owner)`, whose failure causes the enclosing function to trap without revealing the balance or moving any cycles. + +Any caller may `deposit` an amount of cycles, provided the savings will not exceed `capacity`, breaking the piggy bank. Because the deposit function only accepts a portion of the available amount, a caller whose deposit exceeds the limit will receive an implicit refund of any unaccepted cycles. Refunds are automatic and ensured by the ICP infrastructure. + +Since the transfer of cycles is unidirectional from caller to callee, retrieving cycles requires the use of an explicit callback using the `benefit` function, taken by the constructor as an argument. Here, `benefit` is called by the `withdraw` function, but only after authenticating the caller as `owner`. Invoking `benefit` in `withdraw` inverts the caller/caller relationship, allowing cycles to flow upstream. + +Note that the owner of the `PiggyBank` could supply a callback that rewards a beneficiary distinct from `owner`. + +Here’s how an owner, `Alice`, might use an instance of `PiggyBank`: + +``` motoko include=PiggyBank file=../examples/Alice.mo +``` + +`Alice` imports the `PiggyBank` actor class as a library so she can create a new `PiggyBank` actor on demand. + +Most of the action occurs in `Alice`'s `test()` function: + +- Alice dedicates `10_000_000_000_000` of her own cycles for running the piggy bank by calling `Cycles.add(10_000_000_000_000)` just before creating a new instance, `porky`, of the `PiggyBank`, passing callback `Alice.credit` and capacity (`1_000_000_000`). Passing `Alice.credit` nominates `Alice` as the beneficiary of withdrawals. The `10_000_000_000_000` cycles, minus a small installation fee, are credited to `porky`'s balance without any further action by the program's initialization code. You can think of this as an electric piggy bank that consumes its own resources as its used. Since constructing a `PiggyBank` is asynchronous, `Alice` needs to `await` the result. + +- After creating `porky`, she first verifies that the `porky.getSavings()` is zero using an `assert`. + +- `Alice` dedicates `1_000_000` of her cycles (`Cycles.add(1_000_000)`) to transfer to `porky` with the next call to `porky.deposit()`. The cycles are only consumed from Alice’s balance if the call to `porky.deposit()` succeeds. + +- `Alice` now withdraws half the amount, `500_000`, and verifies that `porky`'s savings have halved. `Alice` eventually receives the cycles via a callback to `Alice.credit()`, initiated in `porky.withdraw()`. Note the received cycles are precisely the cycles `add`ed in `porky.withdraw()`, before it invokes its `benefit` callback `Alice.credit`. + +- `Alice` withdraws another `500_000` cycles to wipe out her savings. + +- `Alice` tries to deposit `2_000_000_000` cycles into `porky` but this exceeds `porky`'s capacity by half, so `porky` accepts `1_000_000_000` and refunds the remaining `1_000_000_000` to `Alice`. `Alice` verifies the refund amount (`Cycles.refunded()`), which has been automatically restored to her balance. She also verifies `porky`'s adjusted savings. + +- `Alice`'s `credit()` function simply accepts all available cycles by calling `Cycles.accept(available)`, checking the actually `accepted` amount with an assert. + +:::note + +For this example, Alice is using her readily available cycles that she already owns. + +::: + +:::danger + +Because `porky` consumes cycles in its operation, it is possible for `porky` to spend some or even all of Alice’s cycle savings before she has a chance to retrieve them. + +::: + +Logo + diff --git a/doc/md/canister-maintenance/optimization.md b/doc/md/canister-maintenance/optimization.md new file mode 100644 index 00000000000..f92d08939f0 --- /dev/null +++ b/doc/md/canister-maintenance/optimization.md @@ -0,0 +1,64 @@ +--- +sidebar_position: 2 +--- + +# Optimizing canisters + +## Overview + +The Motoko compiler produces small binaries with reasonably efficient code, but is not a highly optimized compiler. +It is possible to further optimize Motoko binaries, both for code size and cycle usage, using additional tools such as `wasm-opt`. + +## Using `wasm-opt` + +`Wasm-opt` is a general purpose Wasm optimizer that is now available in dfx, versions 0.14.0 and newer. + +`Wasm-opt` can be used to enable canister optimizations through a configuration option in the project's `dfx.json` file, such as: + +```json +{ + "canisters": { + "my_canister": { + "optimize": "cycles" + } + } +} +``` + +### Optimization levels for cycle usage + +Using the `"optimize": "cycles"` option, you can expect a rough estimate of decreased cycles usage for Motoko canisters by around 10%. + +The `"optimize": "cycles"` option is the recommended default, as it maps to optimization level 3 in the `wasm-opt` package. + +The optimization levels for cycles usage are as follows: + +``` +O4 +O3 (equivalent to “cycles”) +O2 +O1 +O0 (performs no optimizations) +``` + +### Optimization levels for binary size + +To optimize the binary size instead, you can use the `"optimize": "size"` option. By using the size option, binary sizes can be reduced by roughly 16%. + +The optimization levels for binary size are as follows: + +``` +Oz (equivalent to “size”) +Os +``` + +Each optimization preserves the Internet Computer specific metadata sections of each canister. + +:::info +Note that in certain cases the optimizations can increase the complexity of certain functions in your Wasm module such that they are rejected by the replica. If you run into this issue, it is recommended to use a less aggressive optimization level such that you do not exceed the complexity limit. +::: + +More information on canister optimization and information on `wasm-opt` benchmark testing can be found [on this forum post](https://forum.dfinity.org/t/canister-optimizer-available-in-dfx-0-14-0/21157). + + +Logo diff --git a/doc/md/canister-maintenance/orthogonal-persistence/_category_.yml b/doc/md/canister-maintenance/orthogonal-persistence/_category_.yml new file mode 100644 index 00000000000..cb2f5e1e941 --- /dev/null +++ b/doc/md/canister-maintenance/orthogonal-persistence/_category_.yml @@ -0,0 +1,4 @@ +position: 5 +label: 'Orthogonal persistence' +collapsible: true # make the category collapsible +collapsed: true diff --git a/doc/md/canister-maintenance/orthogonal-persistence/classical.md b/doc/md/canister-maintenance/orthogonal-persistence/classical.md new file mode 100644 index 00000000000..34776ce5507 --- /dev/null +++ b/doc/md/canister-maintenance/orthogonal-persistence/classical.md @@ -0,0 +1,23 @@ +--- +sidebar_position: 3 +--- + +# Classical orthogonal persistence + +Classical orthogonal persistence is the old implementation of Motoko's orthogonal persistence. It is currently still the default option, as enhanced orthogonal persistence is in the beta-testing stage. + +On an upgrade, the classical orthogonal persistence mechanism serializes all stable data to the stable memory and then deserializes it back to the main memory. This has several downsides: + +* At maximum, 2 GiB of heap data can be persisted across upgrades. This is because of an implementation restriction. Note that in practice, the supported amount of stable data can be way lower. +* Shared immutable heap objects can duplicated, leading to potential state explosion on upgrades. +* Deeply nested structures can lead to a call stack overflow. +* The serialization and deserialization is expensive and can hit IC's instruction limits. +* There is no inbuilt stable compatibility check in the runtime system. If users ignore the `dfx` upgrade warning, data may be lost or an upgrade fails. + +:::danger +All these issues can lead to a stuck canister that can no longer be upgraded. +It is therefore absolutely necessary to thoroughly test how much data an upgrade of your application can handle and then conservatively limit the data held by that canister. +Moreover, it is good to have a backup possibility to rescue data even if upgrades fail, e.g. by controller-privileged data query calls. +::: + +These issues are solved by [enhanced orthogonal persistence](enhanced.md). diff --git a/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md b/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md new file mode 100644 index 00000000000..28d1f310f5a --- /dev/null +++ b/doc/md/canister-maintenance/orthogonal-persistence/enhanced.md @@ -0,0 +1,107 @@ +--- +sidebar_position: 2 +--- + +# Enhanced orthogonal persistence + +Enhanced orthogonal persistence implements the vision of efficient and scalable orthogonal persistence in Motoko that combines: +* **Stable heap**: Persisting the program's main memory across canister upgrades. +* **64-bit heap**: Extending the main memory to 64-bit for large-scale persistence. + +As a result, the use of secondary storage (explicit stable memory, dedicated stable data structures, DB-like storage abstractions) will no longer be necessary: Motoko developers can directly work on their normal object-oriented program structures that are automatically persisted and retained across program version changes. + +### Activation +Enhanced orthogonal persistence is currently offered for **beta testing** via the compiler flag `--enhanced-orthogonal-persistence`. + +To activate enhanced orthogonal persistence under `dfx`, the following command-line argument needs to be specified in `dfx.json`: + +``` +... + "type" : "motoko" + ... + "args" : "--enhanced-orthogonal-persistence" +... +``` + +:::tip +Despite the use of enhanced orthogonal persistence, it is strongly recommended to thoroughly test the upgrades of your application. +Moreover, it is advised to have a backup possibility for rescuing data even when upgrades fail, e.g. by controller-privileged data query calls. +::: + +[Classical orthogonal persistence](classical.md) with 32-bit main memory and Candid stabilization currently remains the default mode. +See [orthogonal persistence modes](modes.md) for a comparison. + +## Design +Compared to the existing orthogonal persistence in Motoko, this design offers: +* **Performance**: New program versions directly resume from the existing main memory and have access to the memory-compatible data. +* **Scalability**: The upgrade mechanism scales with larger heaps and in contrast to serialization, does not hit IC instruction limits. + +Compared to the explicit use of stable memory, this design improves: +* **Simplicity**: Developers do not need to deal with explicit stable memory. +* **Performance**: No copying to and from the separate stable memory is necessary. + +The enhanced orthogonal persistence is based on the following main properties: +* Extension of the IC to retain main memory on upgrades. +* Supporting 64-bit main memory on the IC. +* A long-term memory layout that is invariant to new compiled program versions. +* A fast memory compatibility check that is performed on each canister upgrade. +* Incremental garbage collection using a partitioned heap. + +### Compatibility check +Upgrades are only permitted if the new program version is compatible with the old version, such that the runtime system guarantees a compatible memory structure. + +Compatible changes for immutable types are largely analogous to the allowed Motoko subtype relation modulo some flexibility for actor fields, i.e. +* Adding or removing actor fields. +* Changing mutability of actor fields (`let` to `var` and vice-versa). +* Removing object fields. +* Adding variant fields. +* Changing `Nat` to `Int`. +* Supporting shared function parameter contravariance and return type covariance. +* Any other change according to Motoko's subtyping rule. + +The runtime system checks migration compatibility on upgrade, and if not fulfilled, rolls back the upgrade. This compatibility check serves as an additional safety measure on top of the `dfx` warning that can be bypassed by users. + +Any more complex change can be performed with programmatic instruction, see [explicit migration](../upgrades.md#explicit-migration). + +### Migration path +When migrating from the old serialization-based stabilization to the new persistent heap, the old data is deserialized one last time from stable memory and then placed in the new persistent heap layout. Once operating on the persistent heap, the system should prevent downgrade attempts to the old serialization-based persistence. + +#### Graph-copy-based stabilization +Assuming that the persistent memory layout needs to be changed in the future, the runtime system supports serialization and deserialization to and from stable memory in a defined data format using graph-copy-based stabilization. Arbitrarily large data can be serialized and deserialized beyond the instruction and working set limit of upgrades. Large data serialization and deserialization is split in multiple messages, running before and/or after the IC upgrade to migrate large heaps. Other messages will be blocked during this process and only the canister owner or the canister controllers are permitted to initiate this process. + +This will only be needed in rare situations when Motoko's implementation changes its internal memory layout. Users will then be instructed to explicitly initiate this migration. + +#### Usage +Graph-copy-based stabilization can be performed in three steps: + +1. Initiate the explicit stabilization before the upgrade: + +``` +dfx canister call CANISTER_ID __motoko_stabilize_before_upgrade "()" +``` + +2. Run the actual upgrade: + +``` +dfx deploy CANISTER_ID +``` + +3. Complete the explicit destabilization after the upgrade: + +``` +dfx canister call CANISTER_ID __motoko_destabilize_after_upgrade "()" +``` + +Remarks: +* When receiving the `dfx` error "The request timed out." during explicit stabilization, upgrade, or destabilization, one can simply repeat the call until it completes. +* Step 3 (explicit destabilization) may not be needed if the corresponding operation fits into the upgrade message. + +### Old stable memory +The old stable memory remains equally accessible as secondary (legacy) memory with the new support. Therefore, stable regions can be combined with orthogonal persistence. + +## IC main memory retention + +The IC introduces a new upgrade option `wasm_memory_persistence` to control the retention of the canister's Wasm main memory. +* `wasm_memory_persistence = opt keep` retains the Wasm main memory and is required for Motoko's enhanced orthogonal persistence. The IC prevents using this options for canisters with classical persistence. +* `wasm_memory_persistence = null` uses the classical persistence, replacing the main memory. However, a safety check is implemented to prevent that main memory is not accidentally dropped for enhanced orthogonal persistence. +* The other option `replace` is not recommended as it drops Wasm main memory, even for enhanced orthogonal persistence, leading to potential data loss. diff --git a/doc/md/canister-maintenance/orthogonal-persistence/modes.md b/doc/md/canister-maintenance/orthogonal-persistence/modes.md new file mode 100644 index 00000000000..d723af9341e --- /dev/null +++ b/doc/md/canister-maintenance/orthogonal-persistence/modes.md @@ -0,0 +1,11 @@ +--- +sidebar_position: 1 +--- + +# Persistence modes + +Motoko features two implementations for orthogonal persistence: + +* [Enhanced orthogonal persistence](enhanced.md), currently in beta stage, provides very fast upgrades, scaling independently of the heap size. This is realized by retaining the entire Wasm main memory on an upgrade and simply performing a type-driven upgrade safety check. By using 64-bit address space, it is designed to scale beyond 4 GiB and in the future, offer the same capacity like stable memory. + +* [Classical orthogonal persistence](classical.md) is the old implementation of orthogonal persistence that will be superseded by enhanced orthogonal persistence. On an upgrade, the runtime system first serializes the persistent data to stable memory and then deserializes it back again to main memory. While this is both inefficient and unscalable, it exhibits problems on shared immutable data (potentially leading to state explosion), deep structures (call stack overflow) and larger heaps (the implementation limits the stable data to at most 2 GiB). diff --git a/doc/md/canister-maintenance/upgrades.md b/doc/md/canister-maintenance/upgrades.md new file mode 100644 index 00000000000..1f666bcbf3b --- /dev/null +++ b/doc/md/canister-maintenance/upgrades.md @@ -0,0 +1,231 @@ +--- +sidebar_position: 3 +--- + +# Stable variables and upgrade methods + +## Overview + +One key feature of Motoko is its ability to automatically persist the program's state without explicit user instruction, called **orthogonal persistence**. This not only covers persistence across transactions but also includes canister upgrades. For this purpose, Motoko features a bespoke compiler and runtime system that manages upgrades in a sophisticated way such that a new program version can pick up the state left behind by a previous program version. As a result, Motoko data persistence is not simple but also prevents data corruption or loss, while being efficient at the same time. No database, stable memory API, or stable data structure is required to retain state across upgrades. Instead, a simple `stable` keyword is sufficient to declare an data structure of arbitrary shape persistent, even if the structure uses sharing, has a deep complexity, or contains cycles. + +This is substantially different to other languages supported on the IC, which use off-the-shelf language implementations that are not designed for orthogonal persistence in mind: They rearrange memory structures in an uncontrolled manner on re-compilation or at runtime. As an alternative, in other languages, programmers have to explicitly use stable memory or special stable data structures to rescue their data between upgrades. Contrary to Motoko, this approach is not only cumbersome, but also unsafe and inefficient. Compared to using stable data structures, Motoko's orthogonal persistence allows more natural data modeling and significantly faster data access, eventually resulting in more efficient programs. + +## Declaring stable variables + +In an actor, you can configure which part of the program is considered to be persistent, i.e. survives upgrades, and which part are ephemeral, i.e. are reset on upgrades. + +More precisely, each `let` and `var` variable declaration in an actor can specify whether the variable is `stable` or `flexible`. If you don’t provide a modifier, the variable is assumed to be `flexible` by default. + +The semantics of the modifiers is as follows: +* `stable` means that all values directly or indirectly reachable from that stable actor variable are considered persistent and automatically retained across upgrades. This is the primary choice for most of the program's state. +* `flexible` means that the variable is re-initialized on upgrade, such that the values referenced by this flexible variable can be discarded, unless the values are transitively reachable by other variables that are stable. `flexible` is only used for temporal state or references to high-order types, such as local function references, see [stable types](#stable-types). + +The following is a simple example of how to declare a stable counter that can be upgraded while preserving the counter’s value: + +``` motoko file=../examples/StableCounter.mo +``` + +:::note + +You can only use the `stable` or `flexible` modifier on `let` and `var` declarations that are **actor fields**. You cannot use these modifiers anywhere else in your program. + +::: + +When you first compile and deploy a canister, all flexible and stable variables in the actor are initialized in sequence. When you deploy a canister using the `upgrade` mode, all stable variables that existed in the previous version of the actor are pre-initialized with their old values. After the stable variables are initialized with their previous values, the remaining flexible and newly-added stable variables are initialized in sequence. + +:::danger +Do not forget to declare variables `stable` if they should survive canister upgrades as the default is `flexible` if no modifier is declared. +::: + +## Persistence modes + +Motoko currently features two implementations for orthogonal persistence, see [persistence modes](orthogonal-persistence/modes.md). + +## Stable types + +Because the compiler must ensure that stable variables are both compatible with and meaningful in the replacement program after an upgrade, every `stable` variable must have a stable type. A type is stable if the type obtained by ignoring any `var` modifiers within it is shared. + +The only difference between stable types and shared types is the former’s support for mutation. Like shared types, stable types are restricted to first-order data, excluding local functions and structures built from local functions (such as class instances). This exclusion of functions is required because the meaning of a function value, consisting of both data and code, cannot easily be preserved across an upgrade. The meaning of plain data, mutable or not, can be. + +:::note + +In general, classes are not stable because they can contain local functions. However, a plain record of stable data is a special case of object types that are stable. Moreover, references to actors and shared functions are also stable, allowing you to preserve their values across upgrades. For example, you can preserve the state record of a set of actors or shared function callbacks subscribing to a service. + +::: + +## Converting non-stable types into stable types + +For variables that do not have a stable type, there are two options for making them stable: + +1. Use a `stable` module for the type, such as: + + - [StableBuffer](https://github.com/canscale/StableBuffer) + - [StableHashMap](https://github.com/canscale/StableHashMap) + - [StableRBTree](https://github.com/canscale/StableRBTree) + +:::note +Unlike stable data structures in the Rust CDK, these modules do not use stable memory but rely on orthogonal persistence. The adjective "stable" only denotes a stable type in Motoko. +::: + +2. Extract the state in a stable type, and wrap it in the non-stable type. + +For example, the stable type `TemperatureSeries` covers the persistent data, while the non-stable type `Weather` wraps this with additional methods (local function types). + +```motoko no-repl +actor { + type TemperatureSeries = [Float]; + + class Weather(temperatures : TemperatureSeries) { + public func averageTemperature() : Float { + var sum = 0.0; + var count = 0.0; + for (value in temperatures.vals()) { + sum += value; + count += 1; + }; + return sum / count; + }; + }; + + stable var temperatures : TemperatureSeries = [30.0, 31.5, 29.2]; + flexible var weather = Weather(temperatures); +}; +``` + +3. __Discouraged and not recommended__: [Pre- and post-upgrade hooks](#preupgrade-and-postupgrade-system-methods) allow copying non-stable types to stable types during upgrades. This approach is error-prone and does not scale for large data. **Per best practices, using these methods should be avoided if possible.** Conceptually, it also does not align well with the idea of orthogonal persistence. + +## Stable type signatures + +The collection of stable variable declarations in an actor can be summarized in a stable signature. + +The textual representation of an actor’s stable signature resembles the internals of a Motoko actor type: + +``` motoko no-repl +actor { + stable x : Nat; + stable var y : Int; + stable z : [var Nat]; +}; +``` + +It specifies the names, types and mutability of the actor’s stable fields, possibly preceded by relevant Motoko type declarations. + +:::tip + +You can emit the stable signature of the main actor or actor class to a `.most` file using `moc` compiler option `--stable-types`. You should never need to author your own `.most` file. + +::: + +A stable signature `` is stable-compatible with signature ``, if for each stable field ` : T` in `` one of the following conditions hold: + +- `` does not contain a stable field ``. +- `` has a matching stable field ` : U` with `T <: U`. + +Note that `` may contain additional fields or abandon fields of ``. Mutability can be different for matching fields. + +`` is the signature of an older version while `` is the signature of a newer version. + +The subtyping condition on stable fields ensures that the final value of some field can be consumed as the initial value of that field in the upgraded code. + +:::tip + +You can check the stable-compatibility of two `.most` files containing stable signatures, using `moc` compiler option `--stable-compatible file1.most file2.most`. + +::: + + +## Upgrade safety + +When upgrading a canister, it is important to verify that the upgrade can proceed without: + +- Introducing an incompatible change in stable declarations. +- Breaking clients due to a Candid interface change. + +With [enhanced orthogonal persistence](orthogonal-persistence/enhanced.md), Motoko rejects incompatible changes of stable declarations during upgrade attempt. +Moreover, `dfx` checks the two conditions before attempting then upgrade and warns users correspondingly. + +A Motoko canister upgrade is safe provided: + +- The canister’s Candid interface evolves to a Candid subtype. +- The canister’s Motoko stable signature evolves to a stable-compatible one. + +:::danger +With [classical orthogonal persistence](orthogonal-persistence/classical.md), the upgrade can still fail due to resource constraints. This is problematic as the canister can then not be upgraded. It is therefore strongly advised to test the scalability of upgrades well. Enhanced orthogonal persistence will abandon this issue. +::: + +:::tip + +You can check valid Candid subtyping between two services described in `.did` files using the [`didc` tool](https://github.com/dfinity/candid) with argument `check file1.did file2.did`. + +::: + +## Upgrading a deployed actor or canister + +After you have deployed a Motoko actor with the appropriate `stable` variables, you can use the `dfx deploy` command to upgrade an already deployed version. For information about upgrading a deployed canister, see [upgrade a canister smart contract](/docs/current/developer-docs/smart-contracts/maintain/upgrade). + +`dfx deploy` checks that the interface is compatible, and if not, shows this message and asks if you want to continue: + +``` +You are making a BREAKING change. Other canisters or frontend clients relying on your canister may stop working. +``` + +In addition, Motoko with enhanced orthogonal persistence implements extra safe guard in the runtime system to ensure that the stable data is compatible, to exclude any data corruption or misinterpretation. Moreover, `dfx` also warns about dropping stable variables. + +## Data migration + +Often, data representation changes with a new program version. For orthogonal persistence, it is important the language is able to allow flexible data migration to the new version. + +Motoko supports two kinds of data migrations: Implicit migration and explicit migration. + +### Implicit migration + +This is automatically supported when the new program version is stable-compatible with the old version. The runtime system of Motoko then automatically handles the migration on upgrade. + +More precisely, the following changes can be implicitly migrated: +* Adding or removing actor fields. +* Changing mutability of the actor field. +* Removing record fields. +* Adding variant fields. +* Changing `Nat` to `Int`. +* Shared function parameter contravariance and return type covariance. +* Any change that is allowed by the Motoko's subtyping rule. + +### Explicit migration + +Any more complex migration is possible by user-defined functionality. + +For this purpose, a three step approach is taken: +1. Introduce new variables of the desired types, while keeping the old declarations. +2. Write logic to copy the state from the old variables to the new variables on upgrade. +3. Drop the old declarations once all data has been migrated. + +For more information, see the [example of explicit migration](compatibility.md#explicit-migration). + +## Legacy features + +The following aspects are retained for historical reasons and backwards compatibility: + +### Pre-upgrade and post-upgrade system methods + +:::danger +Using the pre- and post-upgrade system methods is discouraged. It is error-prone and can render a canister unusable. In particular, if a `preupgrade` method traps and cannot be prevented from trapping by other means, then your canister may be left in a state in which it can no longer be upgraded. Per best practices, using these methods should be avoided if possible. +::: + +Motoko supports user-defined upgrade hooks that run immediately before and after an upgrade. These upgrade hooks allow triggering additional logic on upgrade. +These hooks are declared as `system` functions with special names, `preugrade` and `postupgrade`. Both functions must have type `: () → ()`. + +:::danger +If `preupgrade` raises a trap, hits the instruction limit, or hits another IC computing limit, the upgrade can no longer succeed and the canister is stuck with the existing version. +::: + +:::tip +`postupgrade` is not needed, as the equal effect can be achieved by introducing initializing expressions in the actor, e.g. non-stable `let` expressions or expression statements. +::: + +### Stable memory and stable regions + +Stable memory was introduced on the IC to allow upgrades in languages that do not implement orthogonal persistence of the main memory. This is the case with Motoko's classical persistence as well as other languages besides Motoko. + +Stable memory and stable regions can still be used in combination with orthogonal persistence, although there is little practical need for this with enhanced orthogonal persistence and the future large main memory capacity on the IC. + +Logo diff --git a/doc/md/compatibility.md b/doc/md/compatibility.md deleted file mode 100644 index 7ea32cb2b9b..00000000000 --- a/doc/md/compatibility.md +++ /dev/null @@ -1,252 +0,0 @@ -# Verifying upgrade compatibility - -Goal: we need to verify that an upgrade can proceed without: - -- breaking clients (due to a Candid interface change) - -- discarding Motoko stable state (due to a change in stable declarations) - -With Motoko, we promised to check these properties statically (before attempting the upgrade). - -Let’s deliver on that promise. - -## An unstable counter - -The following is a simple example of how to declare a stateful counter. - -``` motoko no-repl file=./examples/count-v0.mo -``` - -Unfortunately, when we upgrade this counter (say with itself), its state is lost. - -| | | | | -|---------|-------|---------|-------------| -| version | state | success | call | -| v0 | 0 | ✓ | inc() | -| v0 | 1 | ✓ | inc() | -| v0 | 2 | ✓ | upgrade(v0) | -| v0 | *0* | *✗* | inc() | -| v0 | 1 | | | - -## A stable counter - -In Motoko, we can declare variables to be stable (across upgrades). - -``` motoko no-repl file=./examples/count-v1.mo -``` - -Because it’s `stable`, this counter’s `state` is *retained* across upgrades. - -(If not marked `stable`, `state` would restart from `0` on upgrade). - -| | | | | -|---------|-------|---------|-------------| -| version | state | success | call | -| v1 | 0 | ✓ | inc() | -| v1 | 1 | ✓ | inc() | -| v1 | 2 | ✓ | upgrade(v1) | -| v1 | 2 | *✓* | inc() | -| v1 | 3 | | | - -## Evolving the Candid interface: - -Let’s extend the API - old clients still satisfied, new ones get extra features (the `read` query). - -``` motoko no-repl file=./examples/count-v2.mo -``` - -| | | | | -|---------|-------|---------|-------------| -| version | state | success | call | -| v1 | 3 | ✓ | inc() | -| v1 | 4 | ✓ | upgrade(v2) | -| v2 | 4 | *✓* | inc() | -| v2 | 5 | ✓ | read() | - -## Changing the stable interface - -Observation: the counter is always positive - let’s refactor `Int` to `Nat`! - -``` motoko no-repl file=./examples/count-v3.mo -``` - -| | | | | -|---------|-------|---------|-------------| -| version | state | success | call | -| v2 | 5 | ✓ | inc() | -| v2 | 6 | ✓ | upgrade(v3) | -| v3 | *0* | *✗* | inc() | -| v3 | 1 | ✓ | read() | - -BOOM: code upgraded, but counter is back to `0`. - -*The unthinkable has happened*: state was lost in an upgrade. - -## What gives? - -The Candid interface evolved safely …​ but the stable types did not. - -An upgrade must be able to: - -- consume any stable variable value from its predecessor, or - -- run the initializer for a new stable variable. - -Since `Int ✓ | \<\<: ✓ | -| `v1` | `v1.did` | `v1.most` | -| | :> ✓ | \<\<: ✓ | -| `v2` | `v2.did` | `v2.most` | -| | :> ✓ | \<\<: *✗* | -| `v3` | `v3.did` | `v3.most` | - -## Tooling - -Motoko compiler (`moc`) now supports: - -- `moc --stable-types …​` emits stable types to a `.most` file - -- `moc --stable-compatible 
 ` checks two `.most` files for upgrade compatibility
-
-To upgrade from `cur.wasm` to `nxt.wasm` we need check both Candid interface and stable variables are "compatible"
-
-    didc check nxt.did cur.did  // nxt <: cur
-    moc --stable-compatible cur.most nxt.most  // cur <<: nxt
-
-E.g. the upgrade from `v2` to `v3` fails this check:
-
-    > moc --stable-compatible v2.most v3.most
-    (unknown location): Compatibility error [M0170], stable variable state of previous type
-      var Int
-    cannot be consumed at new type
-      var Nat
-
-## Examples in the wild
-
-A common, real-world example of an incompatible upgrade can be found on the forum: 
-
-In that example, a user was attempting to add a field to the record payload of an array, by upgrading from stable type interface:
-
-``` motoko no-repl
-type Card = {
-  title : Text
-};
-actor {
-  stable var map: [(Nat32, Card)]
-}
-```
-
-to *incompatible* stable type interface:
-
-``` motoko no-repl
-type Card = {
-  title : Text;
-  description : Text
-};
-actor {
-  stable var map : [(Nat32, Card)]
-}
-```
-
-Adding a new record field (to magic from nothing) does not work.
-
-## Metadata Sections
-
-Motoko embeds `.did` and `.most` files as wasm *custom sections*, for use by other tools, e.g. dfx.
-
-In future, `dfx canister upgrade` will, by default:
-
-1.  query the IC for a canister’s dual interfaces,
-
-2.  check compatibility of the installed and new binary,
-
-3.  abort the upgrade when unsafe.
-
-## Why are we seeing data-loss only now?
-
-A side-effect of a revision to Candid (used for stabilizing variables):
-
--   Previously, upgrades from `v2.wasm` to `v3.wasm` would fail and roll-back (no data loss).
-
--   Candid revision meant upgrade would now "succeed", but *with* data loss.
-
-("fail safe" vs "silent failure")
-
-## The right solution
-
-What if we really do want to change `state` to `Nat`.
-
-Solution: introduce a new stable variable, `newState`, initialized from the old one:
-
-``` motoko no-repl file=./examples/count-v4.mo
-```
-
-``` motoko no-repl file=./examples/count-v4.most
-```
-
-(Or use a variant from the start…​)
diff --git a/doc/md/control-flow.md b/doc/md/control-flow.md
deleted file mode 100644
index a7baaa99d99..00000000000
--- a/doc/md/control-flow.md
+++ /dev/null
@@ -1,203 +0,0 @@
-# Imperative control flow
-
-There are two key categories of control flow:
-
--   *declarative*, when the structure of some value guides control and the selection of the next expression to evaluate, like in `if` and `switch` expressions;
-
--   *imperative* where control changes abruptly according to a programmer’s command, abondoning regular control flow; examples are `break` and `continue`, but also `return` and `throw`.
-
-Imperative control flow often goes hand-in-hand with state changes and other flavors of side-effects, such as error handling and input/output.
-
-## Early `return` from `func`
-
-Normally, the result of a function is the value of its body. Sometimes, during evaluation of the body, the result is available before the end of evaluation. In such situations the `return ` construct can be used to abandon the rest of the computation and immediately exit the function with a result. Similarly, where permitted, `throw` may be used to abandon a computation with an error.
-
-When a function has unit result type, the shorthand `return` may be used instead of the equivalent `return ()`.
-
-## Loops and labels
-
-Motoko provides several kinds of repetition constructs, including:
-
--   `for` expressions for iterating over members of structured data.
-
--   `loop` expressions for programmatic repetition (optionally with termination condition).
-
--   `while` loops for programmatic repetition with entry condition.
-
-Any of these can be prefixed with a `label ` qualifier to give the loop a symbolic name. Named loops are useful for imperatively changing control flow to continue from the entry or exit of the named loop.
-
--   re-entering the loop with `continue `, or
-
--   exiting the loop altogether with `break `.
-
-In the following example, the `for` expression loops over characters of some text and abandons iteration as soon as an exclamation sign is encountered.
-
-``` motoko
-import Debug "mo:base/Debug";
-label letters for (c in "ran!!dom".chars()) {
-  Debug.print(debug_show(c));
-  if (c == '!') { break letters };
-  // ...
-}
-```
-
-### Labeled expressions
-
-There are two other facets to `label`​s that are less mainstream, but come in handy in certain situations:
-
--   `label`​s can be typed
-
--   *any* expression (not just loops) can be named by prefixing it with a label; `break` allows one to short-circuit the expression’s evaluation by providing an immediate value for its result. (This is similar to exiting a function early using `return`, but without the overhead of declaring and calling a function.)
-
-The syntax for type-annotated labels is `label  :  `, signifying that any expression can be exited using a `break  ` construct that returns the value of `` as the value of ``, short-circuiting evaluation of ``.
-
-Judicious use of these constructs allows the programmer to focus on the primary program logic and handle exceptional case via `break`
-
-``` motoko
-import Text "mo:base/Text";
-import Iter "mo:base/Iter";
-
-type Host = Text;
-let formInput = "us@dfn";
-
-let address = label exit : ?(Text, Host) {
-  let splitted = Text.split(formInput, #char '@');
-  let array = Iter.toArray(splitted);
-  if (array.size() != 2) { break exit(null) };
-  let account = array[0];
-  let host = array[1];
-  // if (not (parseHost(host))) { break exit(null) };
-  ?(account, host)
-}
-```
-
-Naturally, labeled common expressions don’t allow `continue`. In terms of typing, both `` and ``​'s types must conform with the label’s declared ``. If a label is only given a ``, then its `` defaults to unit (`()`). Similarly a `break` without an `` is shorthand for the value unit (`()`).
-
-## Option blocks and null breaks
-
-Like many other high-level languages, Motoko lets you opt in to `null` values, tracking possible occurences of `null` values using option types of the form `?T`. This is to both to encourage you to avoid using `null` values when possible, and to consider the possibility of `null` values when necessary.
-
-The latter could be cumbersome, if the only way to test a value for `null` were with a verbose `switch` expression, but Motoko simplifies the handling of option types with some dedicated syntax: *option blocks* and *null breaks*.
-
-The option block, `do ? `, produces a value of type `?T`, when block `` has type `T` and, importantly, introduces the possibility of a break from ``. Within a `do ? `, the null break ` !`, tests whether the result of the expression, ``, of unrelated option type, `?U`, is `null`. If the result `` is `null`, control immediately exits the `do ? ` with value `null`. Otherwise, the result of `` must be an option value `?v`, and evaluation of ` !` proceeds with its contents, `v` (of type `U`).
-
-As realistic example, we give the definition of a simple function `eval`uating numeric `Exp`ressions built from natural numbers, division and a zero test, encoded as a variant type:
-
-
-
-``` motoko file=./examples/option-block.mo
-```
-
-To guard against division by `0` without trapping, the `eval` function returns an option result, using `null` to indicate failure.
-
-Each recursive call is checked for `null` using `!`, immediately exiting the outer `do ? block`, and thus the function itself, with `null`, when a result is `null`.
-
-(As an exercise that illustrates the concision of option blocks, you might want to try rewriting `eval` using a labeled expression and explicit switches for each null break.)
-
-## Repetition with `loop`
-
-The simplest way to indefinitely repeat a sequence of imperative expressions is by using a `loop` construct
-
-``` motoko no-repl
-loop { ; ; ... }
-```
-
-The loop can only be abandoned with a `return` or `break` construct.
-
-A re-entry condition can be affixed to allow a conditional repetition of the loop with `loop  while `.
-
-The body of such a loop is always executed at least once.
-
-## `while` loops with precondition
-
-Sometimes an entry condition is needed to guard the first execution of a loop. For this kind of repetition the `while  `-flavor is available
-
-``` motoko no-repl
-while (earned < need) { earned += earn() };
-```
-
-Unlike a `loop`, the body of a `while` loop may never be executed.
-
-## `for` loops for iteration
-
-An iteration over elements of some homogeneous collection can be performed using a `for` loop. The values are drawn from an iterator and bound to the loop pattern in turn.
-
-``` motoko
-let carsInStock = [
-  ("Buick", 2020, 23.000),
-  ("Toyota", 2019, 17.500),
-  ("Audi", 2020, 34.900)
-];
-var inventory : { var value : Float } = { var value = 0.0 };
-for ((model, year, price) in carsInStock.vals()) {
-  inventory.value += price;
-};
-inventory
-```
-
-## Using `range` with a `for` loop
-
-The `range` function produces an iterator (of type `Iter`) with the given lower and upper bound, inclusive.
-
-The following loop example prints the numbers `0` through `10` over its *eleven* iterations:
-
-``` motoko
-import Iter "mo:base/Iter";
-import Debug "mo:base/Debug";
-var i = 0;
-for (j in Iter.range(0, 10)) {
-  Debug.print(debug_show(j));
-  assert(j == i);
-  i += 1;
-};
-assert(i == 11);
-```
-
-More generally, the function `range` is a `class` that constructs iterators over sequences of natural numbers. Each such iterator has type `Iter`.
-
-As a constructor function, `range` has a function type:
-
-``` motoko no-repl
-(lower : Nat, upper : Int) -> Iter
-```
-
-Where `Iter` is an iterator object type with a `next` method that produces optional elements, each of type `?Nat`:
-
-``` motoko no-repl
-type Iter = {next : () -> ?A};
-```
-
-For each invocation, `next` returns an optional element (of type `?Nat`).
-
-The value `null` indicates that the iteration sequence has terminated.
-
-Until reaching `null`, each non-`null` value, of the form `?`*n* for some number *n*, contains the next successive element in the iteration sequence.
-
-## Using `revRange`
-
-Like `range`, the function `revRange` is a `class` that constructs iterators (each of type `Iter`). As a constructor function, it has a function type:
-
-``` motoko no-repl
-(upper : Int, lower : Int) -> Iter
-```
-
-Unlike `range`, the `revRange` function *descends* in its iteration sequence, from an initial *upper* bound to a final *lower* bound.
-
-## Using iterators of specific data structures
-
-Many built-in data structures come with pre-defined iterators. Below table lists them
-
-| Type      | Name                  | Iterator | Elements                  | Element type |
-|-----------|-----------------------|----------|---------------------------|--------------|
-| `[T]`     | array of `T`​s         | `vals`   | the array’s members       | `T`          |
-| `[T]`     | array of `T`​s         | `keys`   | the array’s valid indices | `Nat`        |
-| `[var T]` | mutable array of `T`​s | `vals`   | the array’s members       | `T`          |
-| `[var T]` | mutable array of `T`​s | `keys`   | the array’s valid indices | `Nat`        |
-| `Text`    | text                  | `chars`  | the text’s characters     | `Char`       |
-| `Blob`    | blob                  | `vals`   | the blob’s bytes          | `Nat8`       |
-
-Iterators for data structures
-
-User-defined data structures can define their own iterators. As long they conform with the `Iter` type for some element type `A`, these behave like the built-in ones and can be consumed with ordinary `for`-loops.
diff --git a/doc/md/cycles.md b/doc/md/cycles.md
deleted file mode 100644
index 2da5456c09f..00000000000
--- a/doc/md/cycles.md
+++ /dev/null
@@ -1,120 +0,0 @@
-# Managing cycles
-
-Usage of the Internet Computer is measured, and paid for, in *cycles*. The Internet Computer maintains a balance of cycles per canister smart contract. In addition, cycles can be transferred between canisters.
-
-In Motoko programs targeting the Internet Computer, each actor represents an Internet Computer canister, and has an associated balance of cycles. The ownership of cycles can be transferred between actors. Cycles are selectively sent and received through messages, that is, shared function calls. A caller can choose to transfer cycles with a call, and a callee can choose to accept cycles that are made available by the caller. Unless explicitly instructed, no cycles are transferred by callers or accepted by callees.
-
-Callees can accept all, some or none of the available cycles up to limit determined by their actor’s current balance. Any remaining cycles are refunded to the caller. If a call traps, all its accompanying cycles are automatically refunded to the caller, without loss.
-
-In future, we may see Motoko adopt dedicated syntax and types to support safer programming with cycles. For now, we provide a temporary way to manage cycles through a low-level imperative API provided by the [ExperimentalCycles](./base/ExperimentalCycles.md) library in package `base`.
-
-:::note
-
-This library is subject to change and likely to be replaced by more high-level support for cycles in later versions of Motoko.
-
-:::
-
-## The `ExperimentalCycles` Library
-
-The `ExperimentalCycles` library provides imperative operations for observing an actor’s current balance of cycles, transferring cycles and observing refunds.
-
-The library provides the following operations:
-
-``` motoko no-repl
-func balance() : (amount : Nat)
-
-func available() : (amount : Nat)
-
-func accept(amount : Nat) : (accepted : Nat)
-
-func add(amount : Nat) : ()
-
-func refunded() : (amount : Nat)
-```
-
-Function `balance()` returns the actor’s current balance of cycles as `amount`. Function `balance()` is stateful and may return different values after calls to `accept(n)`, calling a function after `add`ing cycles, or resuming from await (reflecting a refund).
-
-:::danger
-
-Since cycles measure computational resources spent, the value of `balance()` generally decreases from one shared function call to the next.
-
-:::
-
-Function `available()`, returns the currently available `amount` of cycles. This is the amount received from the current caller, minus the cumulative amount `accept`ed so far by this call. On exit from the current shared function or `async` expression via `return` or `throw` any remaining available amount is automatically refunded to the caller.
-
-Function `accept` transfers `amount` from `available()` to `balance()`. It returns the amount actually transferred, which may be less than requested, for example, if less is available, or if canister balance limits are reached.
-
-Function `add(amount)` indicates the additional amount of cycles to be transferred in the next remote call, i.e. evaluation of a shared function call or `async` expression. Upon the call, but not before, the total amount of units `add`ed since the last call is deducted from `balance()`. If this total exceeds `balance()`, the caller traps, aborting the call.
-
-:::note
-
-the implicit register of added amounts, incremented on each `add`, is reset to zero on entry to a shared function, and after each shared function call or on resume from an await.
-
-:::
-
-Function `refunded()` reports the `amount` of cycles refunded in the last `await` of the current context, or zero if no await has occurred yet. Calling `refunded()` is solely informational and does not affect `balance()`. Instead, refunds are automatically added to the current balance, whether or not `refunded` is used to observe them.
-
-### Example
-
-To illustrate, we will now use the `ExperimentalCycles` library to implement a toy *piggy bank* for saving cycles.
-
-Our piggy bank has an implicit owner, a `benefit` callback and a fixed `capacity`, all supplied at time of construction. The callback is used to transfer *withdrawn* amounts.
-
-``` motoko name=PiggyBank file=./examples/PiggyBank.mo
-```
-
-The owner of the bank is identified with the (implicit) caller of constructor `PiggyBank()`, using the shared pattern, `shared(msg)`. Field `msg.caller` is a `Principal` and is stored in private variable `owner` (for future reference). See [Principals and caller identification](caller-id.md) for more explanation of this syntax.
-
-The piggy bank is initially empty, with zero current `savings`.
-
-Only calls from `owner` may:
-
--   query the current `savings` of the piggy bank (function `getSavings()`), or
-
--   withdraw amounts from the savings (function `withdraw(amount)`).
-
-The restriction on the caller is enforced by the statements `assert (msg.caller ==
-owner)`, whose failure causes the enclosing function to trap, without revealing the balance or moving any cycles.
-
-Any caller may `deposit` an amount of cycles, provided the savings will not exceed `capacity`, breaking the piggy bank. Because the deposit function only accepts a portion of the available amount, a caller whose deposit exceeds the limit will receive an implicit refund of any unaccepted cycles. Refunds are automatic and ensured by the Internet Computer infrastructure.
-
-Since transfer of cycles is one-directional (from caller to callee), retrieving cycles requires the use of an explicit callback (the `benefit` function, taken by the constructor as an argument). Here, `benefit` is called by the `withdraw` function, but only after authenticating the caller as `owner`. Invoking `benefit` in `withdraw` inverts the caller/caller relationship, allowing cycles to flow "upstream".
-
-Note that the owner of the `PiggyBank` could, in fact, supply a callback that rewards a beneficiary distinct from `owner`.
-
-Here’s how an owner, `Alice`, might use an instance of `PiggyBank`:
-
-``` motoko include=PiggyBank file=./examples/Alice.mo
-```
-
-Let’s dissect `Alice`'s code.
-
-`Alice` imports the `PiggyBank` actor class as a library, so she can create a new `PiggyBank` actor on demand.
-
-Most of the action occurs in `Alice`'s `test()` function:
-
-Alice dedicates `10_000_000_000_000` of her own cycles for running the piggy bank, by calling `Cycles.add(10_000_000_000_000)` just before creating a new instance, `porky`, of the `PiggyBank`, passing callback `Alice.credit` and capacity (`1_000_000_000`). Passing `Alice.credit` nominates `Alice` as the beneficiary of withdrawals. The `10_000_000_000_000` cycles, minus a small installation fee, are credited to `porky`'s balance without any further action by `porky` initialization code. You can think of this as an electric piggy bank, that consumes its own resources as its used. Since constructing a `PiggyBank` is asynchronous, `Alice` needs to `await` the result.
-
-After creating `porky`, she first verifies that the `porky.getSavings()` is zero using an `assert`.
-
-`Alice` dedicates `1_000_000` of her cycles (`Cycles.add(1_000_000)`) to transfer to `porky` with the next call to `porky.deposit()`. The cycles are only consumed from Alice’s balance if the call to `porky.deposit()` succeeds (which it should).
-
-`Alice` now withdraws half the amount, `500_000`, and verifies that `porky`'s savings have halved. `Alice` eventually receives the cycles via a callback to `Alice.credit()`, initiated in `porky.withdraw()`. Note the received cycles are precisely the cycles `add`ed in `porky.withdraw()`, before it invokes its `benefit` callback, that is, `Alice.credit`.
-
-`Alice` withdraws another `500_000` cycles to wipe out her savings.
-
-`Alice` vainly tries to deposit `2_000_000_000` cycles into `porky` but this exceeds `porky`'s capacity by half, so `porky` accepts `1_000_000_000` and refunds the remaining `1_000_000_000` to `Alice`. `Alice` verifies the refund amount (`Cycles.refunded()`), which has (already) been automatically restored to her balance. She also verifies `porky`'s adjusted savings.
-
-`Alice`'s `credit()` function simply accepts all available cycles by calling `Cycles.accept(available)`, checking the actually `accepted` amount with an assert.
-
-:::note
-
-For this example, Alice is using her (readily available) cycles, that she already owns.
-
-:::
-
-:::danger
-
-Because `porky` consumes cycles in its operation, it is possible for `porky` to spend some or even all of Alice’s cycle savings before she has a chance to retrieve them.
-
-:::
diff --git a/doc/md/errors.md b/doc/md/errors.md
deleted file mode 100644
index 18ab41b415c..00000000000
--- a/doc/md/errors.md
+++ /dev/null
@@ -1,142 +0,0 @@
-# Errors and Options
-
-There are three primary ways to represent and handle errors values in Motoko:
-
--   Option values (with a non-informative `null` indicated *some* error);
-
--   `Result` variants (with a descriptive `#err value` providing more information about the error); and
-
--   `Error` values (that, in an asynchronous context, can be thrown and caught - similar to exceptions - and contain a numeric code and message).
-
-## Our Example API
-
-Let’s assume we’re building an API for a Todo application and want to expose a function that lets a user mark one of their Todo’s as **Done**. To keep it simple we’ll accept a `TodoId` and return an `Int` that represents how many seconds the Todo has been open. We’re also assuming we’re running in our own actor so we return an async value. If nothing would ever go wrong that would leave us with the following API:
-
-``` motoko no-repl
-func markDone(id : TodoId) : async Int
-```
-
-The full definition of all types and helpers we’ll use in this document is included for reference:
-
-``` motoko no-repl file=./examples/todo-error.mo#L1-L6
-```
-
-``` motoko no-repl file=./examples/todo-error.mo#L10-L37
-```
-
-## When things go wrong
-
-We now realize that there are conditions under which marking a Todo as done fails.
-
--   The `id` could reference a non-existing Todo
-
--   The Todo might already be marked as done
-
-We’ll now talk about the different ways to communicate these errors in Motoko and slowly improve our solution.
-
-## What error type to prefer
-
-### How *not* to do things
-
-One particularly easy and *bad* way of reporting errors is through the use of a *sentinel* value. For example, for our `markDone` function we might decide to use the value `-1` to signal that something failed. The callsite then has to check the return value against this special value and report the error. But it’s way too easy to not check for that error condition and continue to work with that value in our code. This can lead to delayed or even missing error detection and is strongly discouraged.
-
-Definition:
-
-``` motoko no-repl file=./examples/todo-error.mo#L38-L47
-```
-
-Callsite:
-
-``` motoko no-repl file=./examples/todo-error.mo#L108-L115
-```
-
-### Prefer Option/Result over Exceptions where possible
-
-Using `Option` or `Result` is the preferred way of signaling errors in Motoko. They work in both synchronous and asynchronous contexts and make your APIs safer to use (by encouraging clients to consider the error cases as well as the success cases. Exceptions should only be used to signal unexpected error states.
-
-### Error reporting with Option
-
-A function that wants to return a value of type `A` or signal an error can return a value of *option* type `?A` and use the `null` value to designate the error. In our example this means having our `markDone` function return an `async ?Seconds`.
-
-Here’s what that looks like for our `markDone` function:
-
-Definition:
-
-``` motoko no-repl file=./examples/todo-error.mo#L49-L58
-```
-
-Callsite:
-
-``` motoko no-repl file=./examples/todo-error.mo#L117-L126
-```
-
-The main drawback of this approach is that it conflates all possible errors with a single, non-informative `null` value. Our callsite might be interested in why marking a `Todo` as done has failed, but that information is lost by then, which means we can only tell the user that `"Something went wrong."`. Returning option values to signal errors should only be used if there just one possible reason for the failure, and that reason can be easily determined at the callsite. One example of a good usecase for this is a HashMap lookup failing.
-
-### Error reporting with `Result` types
-
-To address the shortcomings of using option types to signal errors we’ll now look at the richer `Result` type. While options are a built-in type, the `Result` is defined as a variant type like so:
-
-``` motoko no-repl
-type Result = { #ok : Ok; #err : Err }
-```
-
-Because of the second type parameter, `Err`, the `Result` type lets us select the type we use to describe errors. So we’ll define a `TodoError` type our `markDone` function will use to signal errors.
-
-``` motoko no-repl file=./examples/todo-error.mo#L60-L60
-```
-
-This lets us now write the third version of `markDone`:
-
-Definition:
-
-``` motoko no-repl file=./examples/todo-error.mo#L62-L76
-```
-
-Callsite:
-
-``` motoko no-repl file=./examples/todo-error.mo#L128-L141
-```
-
-And as we can see we can now give the user a useful error message.
-
-## Working with Option/Result
-
-`Option`s and `Results`s are a different way of thinking about errors, especially if you come from a language with pervasive exceptions. In this chapter we’ll look at the different ways to create, destructure, convert, and combine `Option`s and `Results` in different ways.
-
-### Pattern matching
-
-The first and most common way of working with `Option` and `Result` is to use 'pattern matching'. If we have a value of type `?Text` we can use the `switch` keyword to access the potential `Text` contents:
-
-``` motoko no-repl file=./examples/error-examples.mo#L3-L10
-```
-
-The important thing to understand here is that Motoko does not let you access the optional value without also considering the case that it is missing.
-
-In the case of a `Result` we can also use pattern matching, with the difference that we also get an informative value (not just `null`) in the `#err` case.
-
-``` motoko no-repl file=./examples/error-examples.mo#L12-L19
-```
-
-### Higher-Order functions
-
-Pattern matching can become tedious and verbose, especially when dealing with multiple optional values. The [base](https://github.com/dfinity/motoko-base) library exposes a collection of higher-order functions from the `Optional` and `Result` modules to improve the ergonomics of error handling.
-
-### Converting back and forth between Option/Result
-
-Sometimes you’ll want to move between Options and Results. A Hashmap lookup returns `null` on failure and that’s fine, but maybe the caller has more context and can turn that lookup failure into a meaningful `Result`. At other times you don’t need the additional information a `Result` provides and just want to convert all `#err` cases into `null`. For these situations [base](https://github.com/dfinity/motoko-base) provides the `fromOption` and `toOption` functions in the `Result` module.
-
-## Asynchronous Errors
-
-The last way of dealing with errors in Motoko is to use asynchronous `Error` handling, a restricted form of the exception handling familiar from other languages. Unlike the exceptions of other languages, Motoko *errors* values, can only be thrown and caught in asynchronous contexts, typically the body of a `shared` function or `async` expression. Non-`shared` functions cannot employ structured error handling. This means you can exit a shared function by `throw`ing an `Error` value and `try` some code calling a shared function on another actor, `catch`ing its failure as a result of type `Error`, but you can’t use these error handling constructs in regular code, outside of an asynchronous context.
-
-Asynchronous `Error`s should generally only be used to signal unexpected failures that you cannot recover from, and that you don’t expect many consumers of your API to handle. If a failure should be handled by your caller you should make it explicit in your signature by returning a `Result` instead. For completeness here is the `markDone` example with exceptions:
-
-Definition:
-
-``` motoko no-repl file=./examples/todo-error.mo#L78-L92
-```
-
-Callsite:
-
-``` motoko no-repl file=./examples/todo-error.mo#L143-L150
-```
diff --git a/doc/md/examples/Alice.mo b/doc/md/examples/Alice.mo
index bee3ff12e6b..43c0833308f 100644
--- a/doc/md/examples/Alice.mo
+++ b/doc/md/examples/Alice.mo
@@ -5,12 +5,12 @@ actor Alice {
 
   public func test() : async () {
 
-    Cycles.add(10_000_000_000_000);
+    Cycles.add(10_000_000_000_000);
     let porky = await Lib.PiggyBank(Alice.credit, 1_000_000_000);
 
     assert (0 == (await porky.getSavings()));
 
-    Cycles.add(1_000_000);
+    Cycles.add(1_000_000);
     await porky.deposit();
     assert (1_000_000 == (await porky.getSavings()));
 
@@ -20,7 +20,7 @@ actor Alice {
     await porky.withdraw(500_000);
     assert (0 == (await porky.getSavings()));
 
-    Cycles.add(2_000_000_000);
+    Cycles.add(2_000_000_000);
     await porky.deposit();
     let refund = Cycles.refunded();
     assert (1_000_000_000 == refund);
@@ -31,7 +31,7 @@ actor Alice {
   // Callback for accepting cycles from PiggyBank
   public func credit() : async () {
     let available = Cycles.available();
-    let accepted = Cycles.accept(available);
+    let accepted = Cycles.accept(available);
     assert (accepted == available);
   }
 
diff --git a/doc/md/examples/CompositeSemantics.mo b/doc/md/examples/CompositeSemantics.mo
new file mode 100644
index 00000000000..37f2aa6c602
--- /dev/null
+++ b/doc/md/examples/CompositeSemantics.mo
@@ -0,0 +1,31 @@
+actor Composites {
+
+  var state = 0;
+
+  // ...
+
+  public shared query func q() : async Nat {
+    let s = state;
+    state += 10;
+    s
+  };
+
+  public shared composite query func cq() : async Nat {
+    let s = state;
+    state += 100;
+    s
+  };
+
+  public shared composite query func test() :
+    async {s0 : Nat; s1 : Nat; s2 : Nat; s3 : Nat } {
+    let s0 = state;
+    state += 1000;
+    let s1 = await q();
+    state += 1000;
+    let s2 = await cq();
+    state += 1000;
+    let s3 = state;
+    {s0; s1; s2; s3}
+  };
+
+}
diff --git a/doc/md/examples/CounterWithCompositeQuery.mo b/doc/md/examples/CounterWithCompositeQuery.mo
new file mode 100644
index 00000000000..f7075456cde
--- /dev/null
+++ b/doc/md/examples/CounterWithCompositeQuery.mo
@@ -0,0 +1,19 @@
+actor class Counter () {
+
+  var count = 0;
+
+  // ...
+
+  public shared query func peek() : async Nat {
+    count
+  };
+
+  public shared composite query func sum(counters : [Counter]) : async Nat {
+    var sum = 0;
+    for (counter in counters.vals())  {
+      sum += await counter.peek();
+    };
+    sum
+  }
+
+}
diff --git a/doc/md/examples/InspectArg.mo b/doc/md/examples/InspectArg.mo
index ea94c240582..d2419b008d8 100644
--- a/doc/md/examples/InspectArg.mo
+++ b/doc/md/examples/InspectArg.mo
@@ -1,5 +1,3 @@
-import Principal = "mo:base/Principal";
-
 actor {
 
    var c = 0;
diff --git a/doc/md/examples/InspectName.mo b/doc/md/examples/InspectName.mo
index a1e43a10299..3e5fa2c72dc 100644
--- a/doc/md/examples/InspectName.mo
+++ b/doc/md/examples/InspectName.mo
@@ -1,5 +1,3 @@
-import Principal = "mo:base/Principal";
-
 actor {
 
    var c = 0;
diff --git a/doc/md/examples/InspectTrick.mo b/doc/md/examples/InspectTrick.mo
index 563c1605783..00f8be0b8c6 100644
--- a/doc/md/examples/InspectTrick.mo
+++ b/doc/md/examples/InspectTrick.mo
@@ -1,5 +1,3 @@
-import Principal = "mo:base/Principal";
-
 actor {
 
    var c = 0;
diff --git a/doc/md/examples/PiggyBank.mo b/doc/md/examples/PiggyBank.mo
index 316114e660e..4fb662c952c 100644
--- a/doc/md/examples/PiggyBank.mo
+++ b/doc/md/examples/PiggyBank.mo
@@ -20,7 +20,7 @@ shared(msg) actor class PiggyBank(
     let acceptable =
       if (amount <= limit) amount
       else limit;
-    let accepted = Cycles.accept(acceptable);
+    let accepted = Cycles.accept(acceptable);
     assert (accepted == acceptable);
     savings += acceptable;
   };
@@ -29,7 +29,7 @@ shared(msg) actor class PiggyBank(
     : async () {
     assert (msg.caller == owner);
     assert (amount <= savings);
-    Cycles.add(amount);
+    Cycles.add(amount);
     await benefit();
     let refund = Cycles.refunded();
     savings -= amount - refund;
diff --git a/doc/md/examples/Piped.mo b/doc/md/examples/Piped.mo
new file mode 100644
index 00000000000..a88ed7df7f5
--- /dev/null
+++ b/doc/md/examples/Piped.mo
@@ -0,0 +1,7 @@
+import Iter "mo:base/Iter";
+import List "mo:base/List";
+
+Iter.range(0, 10) |>
+  Iter.toList _ |>
+    List.filter(_, func n { n % 3 == 0 }) |>
+      { multiples = _ };
diff --git a/doc/md/examples/Reminder.mo b/doc/md/examples/Reminder.mo
index 9fc8aa8abba..c1c2c5c5a1d 100644
--- a/doc/md/examples/Reminder.mo
+++ b/doc/md/examples/Reminder.mo
@@ -11,9 +11,9 @@ actor Reminder {
     print("Happy New Year!");
   };
 
-  ignore setTimer(#seconds (solarYearSeconds - abs(now() / 1_000_000_000) % solarYearSeconds),
+  ignore setTimer(#seconds (solarYearSeconds - abs(now() / 1_000_000_000) % solarYearSeconds),
     func () : async () {
-      ignore recurringTimer(#seconds solarYearSeconds, remind);
+      ignore recurringTimer(#seconds solarYearSeconds, remind);
       await remind();
   });
 }
diff --git a/doc/md/examples/StableMultiLog.mo b/doc/md/examples/StableMultiLog.mo
new file mode 100644
index 00000000000..455fb7a4e33
--- /dev/null
+++ b/doc/md/examples/StableMultiLog.mo
@@ -0,0 +1,65 @@
+import Nat64 "mo:base/Nat64";
+import Region "mo:base/Region";
+
+actor StableLog {
+
+  // Index of saved log entry.
+  public type Index = Nat64;
+
+  // Internal representation uses two regions, working together.
+  stable var state = {
+    bytes = Region.new();
+    var bytes_count : Nat64 = 0;
+    elems = Region.new ();
+    var elems_count : Nat64 = 0;
+  };
+
+  // Grow a region to hold a certain number of total bytes.
+  func regionEnsureSizeBytes(r : Region, new_byte_count : Nat64) {
+    let pages = Region.size(r);
+    if (new_byte_count > pages << 16) {
+      let new_pages = ((new_byte_count + ((1 << 16) - 1)) / (1 << 16)) - pages;
+      assert Region.grow(r, new_pages) == pages
+    }
+  };
+
+  // Element = Position and size of a saved a Blob.
+  type Elem = {
+    pos : Nat64;
+    size : Nat64;
+  };
+
+  let elem_size = 16 : Nat64; /* two Nat64s, for pos and size. */
+
+  // Count of elements (Blobs) that have been logged.
+  public func size() : async Nat64 {
+      state.elems_count
+  };
+
+  // Constant-time random access to previously-logged Blob.
+  public func get(index : Index) : async Blob {
+    assert index < state.elems_count;
+    let pos = Region.loadNat64(state.elems, index * elem_size);
+    let size = Region.loadNat64(state.elems, index * elem_size + 8);
+    let elem = { pos ; size };
+    Region.loadBlob(state.bytes, elem.pos, Nat64.toNat(elem.size))
+  };
+
+  // Add Blob to the log, and return the index of it.
+  public func add(blob : Blob) : async Index {
+    let elem_i = state.elems_count;
+    state.elems_count += 1;
+
+    let elem_pos = state.bytes_count;
+    state.bytes_count += Nat64.fromNat(blob.size());
+
+    regionEnsureSizeBytes(state.bytes, state.bytes_count);
+    Region.storeBlob(state.bytes, elem_pos, blob);
+
+    regionEnsureSizeBytes(state.elems, state.elems_count * elem_size);
+    Region.storeNat64(state.elems, elem_i * elem_size + 0, elem_pos);
+    Region.storeNat64(state.elems, elem_i * elem_size + 8, Nat64.fromNat(blob.size()));
+    elem_i
+  }
+
+};
diff --git a/doc/md/examples/StableRegistry.mo b/doc/md/examples/StableRegistry.mo
index 8656dfcc72e..90905b1c9a2 100644
--- a/doc/md/examples/StableRegistry.mo
+++ b/doc/md/examples/StableRegistry.mo
@@ -1,6 +1,5 @@
 import Text "mo:base/Text";
 import Map "mo:base/HashMap";
-import Array "mo:base/Array";
 import Iter "mo:base/Iter";
 
 actor Registry {
@@ -23,10 +22,12 @@ actor Registry {
     map.get(name);
   };
 
+// Using preupgrade is discouraged and should be avoided if possible.
   system func preupgrade() {
     entries := Iter.toArray(map.entries());
   };
 
+// Using postupgrade is discouraged and should be avoided if possible.
   system func postupgrade() {
     entries := [];
   };
diff --git a/doc/md/examples/Unpiped.mo b/doc/md/examples/Unpiped.mo
new file mode 100644
index 00000000000..cb70631dca0
--- /dev/null
+++ b/doc/md/examples/Unpiped.mo
@@ -0,0 +1,7 @@
+import Iter "mo:base/Iter";
+import List "mo:base/List";
+
+{ multiples =
+   List.filter(
+     Iter.toList(Iter.range(0, 10)),
+     func n { n % 3 == 0 }) };
diff --git a/doc/md/examples/count-v0.did b/doc/md/examples/count-v0.did
index f743214c13b..c4b13980af3 100644
--- a/doc/md/examples/count-v0.did
+++ b/doc/md/examples/count-v0.did
@@ -1,3 +1,3 @@
 service : {
-  inc: () -> (int);
-}
+  increment : () -> ();
+};
diff --git a/doc/md/examples/count-v0.mo b/doc/md/examples/count-v0.mo
index 5981d106d44..62ab0849f25 100644
--- a/doc/md/examples/count-v0.mo
+++ b/doc/md/examples/count-v0.mo
@@ -1,10 +1,10 @@
-actor Counter_v0 {
+import Debug "mo:base/Debug";
 
-  var state : Int = 0;
+actor Counter_v0 {
+  var state : Nat = 0;
 
-  public func inc() : async Int {
+  public func increment() : async () {
     state += 1;
-    return state;
+    Debug.print(debug_show (state));
   };
-
-}
+};
diff --git a/doc/md/examples/count-v0.most b/doc/md/examples/count-v0.most
index a1802043bdc..1fe45ff42ed 100644
--- a/doc/md/examples/count-v0.most
+++ b/doc/md/examples/count-v0.most
@@ -1,3 +1,2 @@
-actor {
-  
+actor {  
 };
diff --git a/doc/md/examples/count-v1.did b/doc/md/examples/count-v1.did
index f743214c13b..c4b13980af3 100644
--- a/doc/md/examples/count-v1.did
+++ b/doc/md/examples/count-v1.did
@@ -1,3 +1,3 @@
 service : {
-  inc: () -> (int);
-}
+  increment : () -> ();
+};
diff --git a/doc/md/examples/count-v1.mo b/doc/md/examples/count-v1.mo
index 2cc2360632d..b75935bb314 100644
--- a/doc/md/examples/count-v1.mo
+++ b/doc/md/examples/count-v1.mo
@@ -1,9 +1,10 @@
-actor Counter_v1 {
+import Debug "mo:base/Debug";
 
-  stable var state : Int = 0;
+actor Counter_v1 {
+  stable var state : Nat = 0;
 
-  public func inc() : async Int {
+  public func increment() : async () {
     state += 1;
-    return state;
+    Debug.print(debug_show (state));
   };
-}
+};
diff --git a/doc/md/examples/count-v1.most b/doc/md/examples/count-v1.most
index 31801da83fa..302a837fa10 100644
--- a/doc/md/examples/count-v1.most
+++ b/doc/md/examples/count-v1.most
@@ -1,3 +1,3 @@
 actor {
-  stable var state : Int
+  stable var state : Nat
 };
diff --git a/doc/md/examples/count-v2.did b/doc/md/examples/count-v2.did
index 57e9012e2bb..c4b13980af3 100644
--- a/doc/md/examples/count-v2.did
+++ b/doc/md/examples/count-v2.did
@@ -1,4 +1,3 @@
 service : {
-  inc: () -> (int);
-  read: () -> (int) query;
-}
+  increment : () -> ();
+};
diff --git a/doc/md/examples/count-v2.mo b/doc/md/examples/count-v2.mo
index 95c29027c77..cc288c81b86 100644
--- a/doc/md/examples/count-v2.mo
+++ b/doc/md/examples/count-v2.mo
@@ -1,11 +1,10 @@
-actor Counter_v2 {
+import Debug "mo:base/Debug";
 
+actor Counter_v2 {
   stable var state : Int = 0;
 
-  public func inc() : async Int {
+  public func increment() : async () {
     state += 1;
-    return state;
+    Debug.print(debug_show (state));
   };
-
-  public query func read() : async Int { return state; }
-}
+};
diff --git a/doc/md/examples/count-v3.did b/doc/md/examples/count-v3.did
index 902cf3b1469..cef4206e459 100644
--- a/doc/md/examples/count-v3.did
+++ b/doc/md/examples/count-v3.did
@@ -1,4 +1,5 @@
 service : {
-  inc: () -> (nat);
-  read: () -> (nat) query;
-}
+  increment : () -> ();
+  decrement : () -> ();
+  read : () -> (int) query;
+};
diff --git a/doc/md/examples/count-v3.mo b/doc/md/examples/count-v3.mo
index e9cb87d5c1d..aba6e495f3f 100644
--- a/doc/md/examples/count-v3.mo
+++ b/doc/md/examples/count-v3.mo
@@ -1,11 +1,15 @@
 actor Counter_v3 {
+  stable var state : Int = 0;
 
-  stable var state : Nat = 0;
-
-  public func inc() : async Nat {
+  public func increment() : async () {
     state += 1;
-    return state;
   };
 
-  public query func read() : async Nat { return state; }
-}
+  public func decrement() : async () {
+    state -= 1;
+  };
+
+  public query func read() : async Int {
+    return state;
+  };
+};
diff --git a/doc/md/examples/count-v3.most b/doc/md/examples/count-v3.most
index 302a837fa10..31801da83fa 100644
--- a/doc/md/examples/count-v3.most
+++ b/doc/md/examples/count-v3.most
@@ -1,3 +1,3 @@
 actor {
-  stable var state : Nat
+  stable var state : Int
 };
diff --git a/doc/md/examples/count-v4.mo b/doc/md/examples/count-v4.mo
index f12e2fba784..22234fc879a 100644
--- a/doc/md/examples/count-v4.mo
+++ b/doc/md/examples/count-v4.mo
@@ -1,14 +1,17 @@
-import Int "mo:base/Int";
+import Float "mo:base/Float";
 
 actor Counter_v4 {
+  stable var state : Float = 0.0;
 
-  stable var state : Int = 0;
-  stable var newState : Nat = Int.abs(state);
+  public func increment() : async () {
+    state += 0.5;
+  };
 
-  public func inc() : async Nat {
-    newState += 1;
-    return newState;
+  public func decrement() : async () {
+    state -= 0.5;
   };
 
-  public query func read() : async Nat { return newState; }
-}
+  public query func read() : async Float {
+    return state;
+  };
+};
diff --git a/doc/md/examples/count-v5.mo b/doc/md/examples/count-v5.mo
new file mode 100644
index 00000000000..58843e7b29f
--- /dev/null
+++ b/doc/md/examples/count-v5.mo
@@ -0,0 +1,23 @@
+import Debug "mo:base/Debug";
+import Float "mo:base/Float";
+
+actor Counter_v5 {
+  stable var state : Int = 0;
+  stable var newState : Float = Float.fromInt(state);
+
+  public func increment() : async () {
+    newState += 0.5;
+  };
+
+  public func decrement() : async () {
+    newState -= 0.5;
+  };
+
+  public query func read() : async Int {
+    Debug.trap("No longer supported: Use `readFloat`");
+  };
+
+  public query func readFloat() : async Float {
+    return newState;
+  };
+};
diff --git a/doc/md/examples/count-v6.mo b/doc/md/examples/count-v6.mo
new file mode 100644
index 00000000000..e0c6f0df284
--- /dev/null
+++ b/doc/md/examples/count-v6.mo
@@ -0,0 +1,22 @@
+import Debug "mo:base/Debug";
+import Float "mo:base/Float";
+
+actor Counter_v6 {
+  stable var newState : Float = 0.0;
+
+  public func increment() : async () {
+    newState += 0.5;
+  };
+
+  public func decrement() : async () {
+    newState -= 0.5;
+  };
+
+  public query func read() : async Int {
+    Debug.trap("No longer supported: Use `readFloat`");
+  };
+
+  public query func readFloat() : async Float {
+    return newState;
+  };
+};
diff --git a/doc/md/examples/grammar.txt b/doc/md/examples/grammar.txt
index 8779105766c..24440c86f9e 100644
--- a/doc/md/examples/grammar.txt
+++ b/doc/md/examples/grammar.txt
@@ -12,15 +12,19 @@
     'actor'
     'module'
 
+ ::= 
+    'query'
+    'composite' 'query'
+
  ::= 
     
-    'shared' 'query'?
-    'query'
+    'shared' ?
+    
 
  ::= 
     
-    'shared' 'query'? ?
-    'query' ?
+    'shared' ? ?
+     ?
 
  ::= 
     '{' , ';')> '}'
@@ -48,7 +52,7 @@
 
  ::= 
     
-     ('<' , ',')> '>')?  '->' 
+       '->' 
 
  ::= 
     
@@ -62,10 +66,19 @@
  ::= 
     '<' , ',')> '>'
 
+ ::= 
+    
+    '<' , ',')> '>'
+    '<' 'system' (',' )* '>'
+
+ ::= 
+    ('<' , ',')> '>')?
+    '<' 'system' (',' )* '>'
+
  ::= 
     'type'  ('<' , ',')> '>')? '=' 
     'var'?  ':' 
-     ('<' , ',')> '>')?  ':' 
+       ':' 
 
  ::= 
     '#'  (':' )?
@@ -153,6 +166,7 @@
     
     
     
+    '_'
 
  ::= 
     
@@ -160,7 +174,7 @@
      '['  ']'
      '.'
      '.' 
-     ('<' , ',')> '>')? 
+      
      '!'
     '(' 'system'  '.'  ')'
 
@@ -184,6 +198,7 @@
      'and' 
      'or' 
      ':' 
+     '|>' 
 
  ::= 
     
@@ -191,7 +206,7 @@
       
     'return' ?
     'async' 
-    'async*' 
+    'async*' 
     'await' 
     'await*' 
     'assert' 
@@ -202,6 +217,8 @@
     'if'  
     'if'   'else' 
     'try'  
+    'try'   'finally' 
+    'try'  'finally' 
     'throw' 
     'switch'  '{' , ';')> '}'
     'while'  
@@ -286,9 +303,9 @@
  ::= 
     'let'  '=' 
     'type'  ('<' , ',')> '>')? '=' 
-     ? '='? 
-     'func' ? ('<' , ',')> '>')?  (':' )? 
-     ? 'class' ? ('<' , ',')> '>')?  (':' )? 
+     ? (':' )? '='? 
+     'func' ?   (':' )? 
+     ? 'class' ?   (':' )? 
 
  ::= 
     
diff --git a/doc/md/examples/try-finally.mo b/doc/md/examples/try-finally.mo
new file mode 100644
index 00000000000..a8deebc6d92
--- /dev/null
+++ b/doc/md/examples/try-finally.mo
@@ -0,0 +1,18 @@
+import Text "mo:base/Text";
+import Debug "mo:base/Debug"
+
+actor {
+    public func tryFunction() {
+
+        try {
+            func greetOptional(optionalName : ?Text) : Text =
+                switch optionalName {
+                    case null { "No name to be found." };
+                    case (?name) { "Hello, " # name # "!" };
+                };
+            assert greetOptional(?"Motoko") == "Motoko";
+        } finally {
+            Debug.print("Finally block executed");
+        }
+    }
+}
diff --git a/doc/md/getting-started/_category_.yml b/doc/md/getting-started/_category_.yml
new file mode 100644
index 00000000000..17cd578b5dc
--- /dev/null
+++ b/doc/md/getting-started/_category_.yml
@@ -0,0 +1,4 @@
+position: 1
+label: 'Getting started'
+collapsible: true # make the category collapsible
+collapsed: true 
diff --git a/doc/md/getting-started/basic-concepts.md b/doc/md/getting-started/basic-concepts.md
new file mode 100644
index 00000000000..31eb8967a82
--- /dev/null
+++ b/doc/md/getting-started/basic-concepts.md
@@ -0,0 +1,209 @@
+---
+sidebar_position: 2
+---
+
+# Basic concepts and terms
+
+## Overview
+
+Motoko is designed for distributed programming with **actors**. When programming on ICP in Motoko, each actor represents an ICP canister smart contract with a Candid interface.
+Within Motoko, the term actor is used to refer to any canister authored in any language that deploys to ICP. The role of Motoko is to make these actors easy to author and use programmatically once deployed.
+
+Before you begin writing canisters in Motoko, you should be familiar with a few of the basic concepts and terms specific to Motoko.
+
+## Values
+
+### Primitive values
+
+Motoko supports the following primitive types and values:
+
+-   [`Bool`](../base/Bool.md): Boolean values (`true` and `false`).
+
+-   [`Int`](../base/Int.md): Integers (…​,`-2`, `-1`, `0`, `1`, `2`, …​) - bounded and unbounded variants.
+
+-   [`Nat`](../base/Nat.md): Natural numbers (`0`, `1`, `2`, …​) - bounded and unbounded variants.
+
+- `Char`: Unicode text characters (`'a'`, `'B'`,  `'☃'`).
+
+-   [`Text`](../base/Text.md): Text values of strings of unicode characters.
+
+By default, **integers** and **natural numbers** are **unbounded** and do not overflow. Instead, they use representations that grow to accommodate any finite number.
+
+For practical reasons, Motoko also includes **bounded** types for integers and natural numbers, distinct from the default versions. Each bounded variant has a fixed bit-width (one of `8`, `16`, `32`, `64`) that determines the range of representable values, and each carries the potential for overflow. Exceeding a bound is a run-time fault that causes the program to [trap](#traps-due-to-faults).
+
+There are no unchecked, uncaught overflows in Motoko, except in well-defined situations, for explicitly **wrapping** operations, indicated by a conventional `%` character in the operator. The language provides primitive built-ins to convert between these various number representations.
+
+### Non-primitive values
+
+Motoko permits user-defined types and each of the following non-primitive value forms and associated types:
+
+-   [Tuples](../reference/language-manual#tuples), including the unit value (the "empty tuple").
+
+-   [Arrays](../reference/language-manual#arrays) with both **immutable** and **mutable** variants.
+
+-   [Objects](../reference/language-manual#objects) with named, unordered fields and methods.
+
+-   [Variants](../reference/language-manual#variant-types) with named constructors and optional payload values.
+
+-   [Function values](../reference/language-manual#functions) including [shareable functions](../writing-motoko/sharing.md).
+
+-   [Async values](../reference/language-manual#async), also known as **promises** or **futures**;
+
+-   [Error values](../reference/language-manual#error-type) carry the payload of exceptions and system failures.
+
+For precise language definitions of primitive and non-primitive values, see the [language reference](../reference/language-manual).
+
+## Printing values
+
+The function `print`, from base library [`Debug`](../base/Debug.md), accepts a text string of type [`Text`](../base/Text.md) as input, and produces the unit value of unit type or `()`, as its output.
+
+Because unit values carry no information, all values of type unit are identical, so the `print` function doesn’t actually produce an interesting result. Instead of a result, the function `print` has the effect of emitting the text string in a human-readable form to the output terminal. Functions that have side effects, such as emitting output or modifying state, are often called **impure**. Functions that just return values without further side-effects, are called **pure**.
+
+You can transform most Motoko values into human-readable text strings for debugging purposes, without having to write those transformations by hand. The `debug_show` primitive permits converting a large class of values into values of type [`Text`](../base/Text.md).
+
+## Motoko program syntax
+
+Each Motoko program is comprised of **declarations** and **expressions** whose syntactic classes are distinct but [related](../reference/language-manual).
+
+Declarations introduce **immutable variables**, **mutable state**, **actors**, **objects**, **classes** and other types. Declarations can be mutually recursive, but in cases where they are not, they permit substitution semantics such as replacing values with an equal value.
+
+Expressions describe computations that involve these notions.
+
+To deploy a valid program to ICP, the program must consist of an actor expression introduced with the keyword `actor`.
+
+As a starting point, the following code snippet consists of two declarations for the variables `x` and `y` followed by an expression to form a single program:
+
+``` motoko
+let x = 1;
+let y = x + 1;
+x * y + x;
+```
+
+This program’s type is [`Nat`](../base/Nat.md) (natural number), and when run, it evaluates to the [`Nat`](../base/Nat.md) value of `3`.
+
+This program is a declaration list that consists of three declarations:
+
+1.  Immutable variable `x`, via declaration `let x = 1;`.
+
+2.  Immutable variable `y`, via declaration `let y = x + 1;`.
+
+3.  An unnamed, implicit variable holding the final expression’s value, `x * y + x`.
+
+The expression `x * y + x` illustrates that each expression can be thought of as a declaration where necessary, since the language implicitly declares an unnamed variable with that expression’s result value.
+
+When the expression appears as the final declaration, this expression may have any type. Here, the expression `x * y + x` has type [`Nat`](../base/Nat.md).
+
+Expressions that do not appear at the end, but rather within the list of declarations must have unit type `()`.
+
+Unit-type restrictions can be ignored by explicitly using the `ignore` keyword to disregard any unused result values.
+
+## Lexical scoping
+
+A declaration list is not itself an expression, so you cannot declare another variable with its final value.
+
+**Block expressions** can be formed from a list of declarations by enclosing it with matching curly braces. Blocks are only allowed as sub-expressions of control flow expressions like `if`, `loop`, `case`, etc. A block expression produces a value and, when enclosed in parentheses, can occur within some larger, compound expression.
+
+:::note
+
+A particular form of blocks are provided for convenience when processing data that may be missing or incomplete. These are described under [option blocks](../writing-motoko/pattern-matching.md#option-blocks-for-streamlined-processing-of-optional-data).
+
+:::
+
+In all other places, `do { … }` is used to represent block expressions and distinguish blocks from object literals. For example, `do {}` is the empty block of type `()`, while `{}` is an empty record of record type `{}`. This block form preserves the autonomy of the declaration list and its choice of variable names. This means that variables' scopes may nest, but they may not interfere as they nest. Language theorists call this idea **lexical scoping**.
+
+Aside from mathematical clarity, the chief practical benefit of lexical scoping is security and its use in building compositionally-secure systems. Specifically, Motoko gives very strong composition properties. For example, nesting your program within a program you do not trust cannot arbitrarily redefine your variables with different meanings.
+
+## Type soundness
+
+Each Motoko expression that type checks is considered **well-typed**. The **type** of a Motoko expression serves as a promise from the language to the developer about the future behavior of the program, if executed.
+
+First, each well-typed program will evaluate without undefined behavior. There is a precise space of meaningful programs. The type system enforces that programs stay within it and that all well-typed programs have a precise meaning.
+
+Furthermore, the types make a precise prediction over the program’s result. If it yields control, the program will generate a **result value** that agrees with that of the original program.
+
+In either case, the static and dynamic views of the program are linked by and agree with the static type system. This agreement is the central principle of a static type system, and is delivered by Motoko as a core aspect of its design.
+
+The same type system also enforces that asynchronous interactions agree between static and dynamic views of the program, and that the resulting messages generated never mismatch at runtime. This agreement is similar in spirit to the caller/callee argument type and return type agreements that one ordinarily expects in a typed language.
+
+## Type annotations and variables
+
+Variables relate static names and static types with dynamic values that are present only at runtime.
+
+In this sense, Motoko types provide a form of trusted, compiler-verified documentation in the program source code.
+
+Consider this very short program:
+
+``` motoko
+let x : Nat = 1
+```
+
+In this example, the compiler infers that the expression `1` has type [`Nat`](../base/Nat.md), and that `x` has the same type.
+
+In this case, we can omit this annotation without changing the meaning of the program:
+
+``` motoko
+let x = 1
+```
+
+Except for some esoteric situations involving operator overloading, type annotations do not typically affect the meaning of the program as it runs. If they are omitted and the compiler accepts the program, as is the case above, the program has the same meaning and behavior as it did originally.
+
+However, sometimes type annotations are required by the compiler to infer other assumptions and to check the program as a whole. When they are added and the compiler still accepts the program, you can confirm that the added annotations are consistent with the existing ones.
+
+## Type errors and messages
+
+Motoko is a statically typed programming language. That means that the compiler will reject any program that contains obviously non-sensical code.
+
+For example, while adding two numbers is allowed, adding a number to a text value makes no sense to the Motoko compiler and is flagged as an error that must be fixed before the code can be run or deployed.
+
+The rules that Motoko applies to verify the correctness of code before compiling and running it are called its type system. Motoko's type system will detect and reject static errors such as applying a function to the wrong number of arguments, or to arguments of the wrong type.
+
+The type system is a safety feature that prevents a slew of errors that would otherwise have to be detected and reported at runtime, when they would be difficult or impossible to address.
+
+
+## Motoko base library
+
+For various practical language engineering reasons, the design of Motoko strives to minimize built-in types and operations.
+
+Instead, whenever possible, the Motoko base library provides the types and operations that make the language feel complete. However, this base library is still under development, and is still incomplete.
+
+The [Motoko base library](../base/index.md) lists a selection of modules, focusing on core features used in the examples that are unlikely to change radically. The base library APIs will likely evolve over time and in particular, grow in size and number as Motoko matures.
+
+To import from the base library, use the `import` keyword. Give a local module name to introduce, in this example `D` for “**D**ebug”, and a URL where the `import` declaration may locate the imported module:
+
+``` motoko file=../examples/print.mo
+```
+
+In this case, we import Motoko code with the `mo:` prefix, specify the `base/` path, followed by the module’s file name `Debug.mo` minus its extension.
+
+## Traps
+
+Some errors, such as division by zero, out-of-bounds array indexing, and pattern match failure are by design not prevented by the type system, but instead cause dynamic faults called **traps**.
+
+Because the meaning of execution is ill-defined after a faulting trap, execution of the code ends by aborting at the trap.
+
+:::note
+
+Traps that occur within actor messages are more subtle: they don’t abort the entire actor, but prevent that particular message from proceeding, rolling back any yet uncommitted state changes. Other messages on the actor will continue execution. This has subtle security implications, so be sure to consult the relevant [security recommendations](https://internetcomputer.org/docs/current/developer-docs/security/security-best-practices/inter-canister-calls#recommendation).
+
+:::
+
+Occasionally it can be useful to force an unconditional trap, with a user-defined message.
+
+The [`Debug`](../base/Debug.md) library provides the function `trap(t)` for this purpose, which can be used in any context:
+
+``` motoko
+import Debug "mo:base/Debug";
+
+Debug.trap("oops!");
+```
+
+**Assertions** allow you to conditionally trap when some Boolean test fails to hold, but continue execution otherwise:
+
+``` motoko no-repl
+let n = 65535;
+assert n % 2 == 0; // traps when n not even
+```
+
+Because an assertion may succeed, and thus proceed with execution, it may only be used in context where a value of type `()` is expected.
+
+Logo
diff --git a/doc/md/getting-started/dev-env.md b/doc/md/getting-started/dev-env.md
new file mode 100644
index 00000000000..ea923eba016
--- /dev/null
+++ b/doc/md/getting-started/dev-env.md
@@ -0,0 +1,146 @@
+---
+sidebar_position: 3
+---
+
+
+# Developer environment
+
+## Overview
+
+To develop and deploy Motoko canister smart contracts, you will need a developer environment that contains the Motoko compiler and base library. It is recommended to use the [IC SDK](https://github.com/dfinity/sdk#readme), which includes Motoko, along with `dfx`, a command-line tool used to create, build, and deploy canisters on ICP.
+
+Developer environments come in several types and formats, making developing flexible and accessible.
+
+## Cloud environments
+
+[Gitpod](https://www.gitpod.io/) and [GitHub Codespaces](https://github.com/features/codespaces) are browser-based development environments that can be used to build, test, and run Motoko smart contracts.
+
+Here are some starter projects for online Motoko canister development:
+
+* [ICP Hello World Motoko](https://github.com/dfinity/icp-hello-world-motoko#readme)
+* [Vite + React + Motoko](https://github.com/rvanasa/vite-react-motoko#readme)
+
+Learn more about [Gitpod](/docs/current/developer-docs/developer-tools/ide/gitpod) and [GitHub Codespaces](/docs/current/developer-docs/developer-tools/ide/codespaces) for Motoko development.
+
+## Container environments
+
+Developers may want to setup a containerized environment for Motoko and other ICP-related development. Container environments are especially useful for Windows-based systems, since `dfx` is not natively supported on Windows.
+
+Learn more about [developer containers](/docs/current/developer-docs/developer-tools/ide/dev-containers) and [Docker containers](/docs/current/developer-docs/developer-tools/ide/dev-containers#using-docker-directly) for Motoko development.
+
+## Motoko playground
+
+[Motoko playground](https://play.motoko.org/) is a browser-based developer environment that allows for temporary deployment and testing of canister smart contracts. Motoko playground can also be utilized through the `dfx deploy --playground` command via the CLI.
+
+Canisters deployed to the Motoko playground use borrowed resources from a canister pool and are limited to a deployment length of 20 minutes. Therefore, the playground is not recommended for long-term development.
+
+Learn more about the [Motoko playground](/docs/current/developer-docs/developer-tools/ide/playground).
+
+## Local developer environment
+
+Before you start developing Motoko, verify the following:
+
+- [x] You have an internet connection and access to a shell terminal on your local macOS or Linux computer.
+
+- [x] You have a command line interface (CLI) window open. This window is also referred to as the 'terminal' window.
+
+- [x] You have downloaded and installed the IC SDK package as described in the [installing the IC SDK](/docs/current/developer-docs/getting-started/install) page.
+
+- [x] You have a code editor installed. The [VS Code IDE](https://code.visualstudio.com/download) (with the [Motoko extension](https://marketplace.visualstudio.com/items?itemName=dfinity-foundation.vscode-motoko)) is a popular choice.
+
+- [x] You have downloaded and installed [git](https://git-scm.com/downloads).
+
+- [x] Assure that all packages and tools above are updated to the latest release versions.
+
+## Motoko version
+
+The following table details which version of Motoko shipped with each major version of the IC SDK. 
+
+| IC SDK version  | Motoko version   |
+|-----------------|------------------|
+| 0.20.0          | 0.11.1           |
+| 0.19.0          | 0.11.1           |
+| 0.18.0          | 0.11.0           |
+| 0.17.0          | 0.10.4           |  
+| 0.16.0          | 0.10.4           |
+| 0.15.0          | 0.9.7            |
+| 0.14.0          | 0.8.7            |
+| 0.13.0          | 0.7.6            |
+| 0.12.0          | 0.7.3            |
+| 0.11.0          | 0.6.29           |
+| 0.10.0          | 0.6.26           |
+| 0.9.0           | 0.6.20           |
+| 0.8.0           | 0.6.5            |
+| 0.7.0           | 0.6.1            |
+
+
+You can find out which version of Motoko shipped with a version of the IC SDK through the following file:
+
+```
+https://github.com/dfinity/sdk/blob//nix/sources.json#L144
+```
+
+Replace `` with the IC SDK release version, such as `0.14.2`.
+
+## Custom developer environment
+
+### Specifying a custom version of the compiler
+
+To specify a custom version of the Motoko compiler to be used with `dfx`, you can use the package manager `mops` or `vessel`.
+
+For `mops`, use the following command to download a different version of the Motoko compiler (`moc`):
+
+```
+mops toolchain use moc 0.10.3
+```
+
+For `vessel`, set the following environment variable:
+
+```
+DFX_MOC_PATH="$(vessel bin)/moc" dfx deploy
+```
+
+## Specifying a custom version of the base library
+
+To specify a custom version of the Motoko base library to be used with `dfx`, you can use the package manager `mops` with the following command:
+
+```
+mops add base@
+```
+
+For example, to use base library version `0.9.0`, use the command:
+
+```
+mops add base@0.9.0
+```
+
+### Specifying a custom version of `dfx`
+
+To specify a custom version of `dfx`, you can use the [`dfxvm` tool](/docs/current/developer-docs/developer-tools/cli-tools/dfxvm/docs/cli-reference/dfxvm/dfxvm-default). To set a default `dfx` version to be used in your project, run the command:
+
+```
+$ dfxvm default 0.7.2
+...
+info: installed dfx 0.7.2
+info: set default version to dfx 0.7.2
+```
+
+### Pass flags to `moc` in `dfx.json`
+
+You can pass flags directly to `moc` by adding an `args` field in your Motoko canister's description in your project's `dfx.json` file:
+
+Here is an example `dfx.json` canister configuration that uses `args`:
+
+```json
+...
+  "canisters": {
+    "hello": {
+      "type": "motoko",
+      "main": "src/hello/main.mo",
+      "args": "-v --incremental-gc"
+    },
+  }
+...
+```
+
+Logo
diff --git a/doc/md/getting-started/examples.md b/doc/md/getting-started/examples.md
new file mode 100644
index 00000000000..c22bd82875f
--- /dev/null
+++ b/doc/md/getting-started/examples.md
@@ -0,0 +1,112 @@
+---
+sidebar_position: 5
+---
+
+# Sample projects and resources
+
+## Overview
+
+Want to get started building with Motoko? Check out some of these sample projects and Motoko resources to help you get started.
+
+## Sample apps
+
+### Canister management
+
+- [Canister app](https://github.com/canister-app): A series of tools for canister tools written in Motoko.
+
+- [Canister Geek](https://github.com/usergeek/canistergeek-ic-motoko): Canister cycle monitoring and management.
+
+- [Canister tip jar](https://github.com/ninegua/tipjar): Donate cycles to a canister on ICP.
+
+- [iCAN](https://github.com/PrimLabs/iCAN): A canister management platform for creating and managing canisters conveniently.
+
+- [ic-blackhole](https://github.com/ninegua/ic-blackhole): An example of a black hole canister.
+
+- [motoko_top_up_canister](https://github.com/ORIGYN-SA/motoko_top_up_canister): A Motoko canister that automatically tops up a user-defined list of canisters.
+
+### Games, social, and utility samples
+
+- [Bitshop](https://github.com/lukasvozda/bitshop): A Shopify alternative that accepts Bitcoin payments.
+
+- [Cleansheets](https://github.com/matthewhammer/cleansheets): A spreadsheet application.
+
+- [DocToken](https://github.com/ava-vs/doctoken): Document storage.
+
+- [EVM proof verifier](https://github.com/horizonx-tech/evm-proof-verifier-motoko): Verify EVM proofs using a Motoko canister.
+
+- [Flower power DAO](https://github.com/flowerpowerdao/power-equalizer-v3).
+
+- [Formyfi](https://github.com/Talentum-id/formify): Question and answer forms.
+
+- [HTTP server for Motoko](https://github.com/krpeacock/server): A simple HTTP server.
+
+- [IC Payroll](https://github.com/cosmasken/ic-payroll): A simple payroll dapp that allows users to be paid in ckBTC.
+
+- [Metabomb](https://github.com/av1ctor/metamob): A campaign dapp for fundraising or donations.
+
+- [NacDB](https://github.com/vporton/NacDB): A distributed database.
+
+- [Play to earn game sample](https://github.com/therealbryanho/IC-Code-Sample-Unity-Play-to-Earn-Game): A simple play to earn game template.
+
+- [Rakeoff statistics](https://github.com/rakeoff-labs/rakeoff_statistics): A Motoko canister that provides statistic analysis for the [Rakeoff application](https://app.rakeoff.io/).
+
+- [Reversi](https://github.com/ninegua/reversi): A multiplayer Reversi game.
+
+- [Revo](https://github.com/DepartureLabsIC/revo): A drawing game.
+
+- [SecureGuard Escrow](https://github.com/bix-tech/secure-guard-escrow): ICP-based escrow platform.
+
+### Tokens & DeFi
+
+- [Appic](https://github.com/Appic-Solutions/Auto_Investment): Automatically by and sell tokens at a specific interval or time.
+
+- [ICDex](https://github.com/iclighthouse/ICDex): An onchain orderbook decentralized exchange written in Motoko.
+
+- [icrc7_motoko](https://github.com/noku-team/icrc7_motoko) and - [icrc7-mo](https://github.com/PanIndustrial-Org/icrc7.mo): Motoko implementations of the ICRC-7 NFT standard.
+
+- [icrc-nft-mo](https://github.com/PanIndustrial-Org/icrc_nft.mo): An example NFT that combines `icrc7-mo`, `icrc30-mo`, and `icrc3-mo`.
+
+- [ic-token](https://github.com/rocklabs-io/ic-token) and [motoko-token](https://github.com/enzoh/motoko-token): Motoko implementations of an ERC-20 token.
+
+- [Itoka music NFT](https://github.com/Itoka-DAO/itoka-music-nft-standard): A standard for music NFTs.
+
+- [Motoko Bitcoin](https://github.com/tgalal/motoko-bitcoin): A Motoko Bitcoin integration.
+
+- [Staking pool](https://github.com/ICTO-Labs/staking-pool): A staking pool project written in Motoko.
+
+- [Token faucet](https://github.com/rocklabs-io/token-faucet): A token faucet for [ic-token](https://github.com/rocklabs-io/ic-token).
+
+- [Token minter sample](https://github.com/icpipeline-framework/mbt): A sample app that mints tokens.
+
+### Writing Motoko
+
+- [Blocks](https://blocks-editor.github.io/blocks/): A Motoko smart contract editor.
+
+- [JSON for Motoko](https://github.com/aviate-labs/json.mo): Motoko JSON library.
+
+- [motoko-library-template](https://github.com/kritzcreek/motoko-library-template): Template for creating Motoko libraries.
+
+- [Motoko Pilot](https://d7dm6-sqaaa-aaaag-qcgma-cai.icp0.io/): An AI tool for writing Motoko.
+
+- [Motoko starter](https://github.com/motoko-bootcamp/motoko-starter): Basic starter template for Motoko projects.
+
+- [Vite + React + Motoko template](https://github.com/rvanasa/vite-react-motoko): Boilerplate template for Vite, React, and Motoko.
+
+- [Visual Studio Code Motoko extension](https://github.com/dfinity/vscode-motoko): A VS Code extension for Motoko.
+
+
+## Education resources
+
+- [Awesome Motoko](https://github.com/ic123-xyz/awesome-motoko): A list of Motoko projects, tools, and resources.
+
+- [DFINITY Examples](https://github.com/dfinity/examples/tree/master/motoko): Simple Motoko sample projects and templates.
+
+- [ICP developer journey](https://internetcomputer.org/docs/current/tutorials/developer-journey/): A 36-part series focused on Motoko development for ICP canisters.
+
+- [Motoko Auction summer camp example](https://github.com/luc-blaeser/auction).
+
+- [Motoko book](https://github.com/Web3NL/motoko-book): An educational book on Motoko.
+
+- [Motoko Bootcamp](https://github.com/motoko-bootcamp/education): Lessons and lectures on Motoko development.
+
+Logo
diff --git a/doc/md/getting-started/motoko-introduction.md b/doc/md/getting-started/motoko-introduction.md
new file mode 100644
index 00000000000..b4d450cade0
--- /dev/null
+++ b/doc/md/getting-started/motoko-introduction.md
@@ -0,0 +1,98 @@
+---
+sidebar_position: 1
+---
+
+# Introduction
+
+## Overview
+
+Motoko is a modern, general-purpose programming language you can use specifically to author ICP canister smart contracts. Although aimed primarily at ICP canister development, its design is general enough to support future compilation to other targets.
+
+Motoko is designed to be approachable for programmers who have some basic familiarity with object-oriented and/or functional programming idioms in either JavaScript, or another modern programming language, such as Rust, Swift, TypeScript, C#, or Java.
+
+Motoko provides:
+
+-   A high-level language for programming applications to run on ICP.
+
+-   A simple design that uses familiar syntax that is easy for programmers to learn.
+
+-   An **actor-based** programming model optimized for efficient message handling.
+
+-   **Orthogonal persistence** for simple, safe, and efficient data storage without a database or secondary memory.
+
+-   An interpreter and compiler that you can use to test and compile the WebAssembly code for autonomous applications.
+
+# Why Motoko?
+
+ICP supports programs written in different languages. The only requirement is that the program must support compilation to WebAssembly code. WebAssembly is a low-level computer instruction format for virtual machines. Because WebAssembly code is designed to provide portable low-level instructions that enable applications to be deployed on many platforms such as the web, it is a natural fit for deploying applications that are intended to run on ICP. However, most of the higher-level languages that support compiling to WebAssembly are either unsafe or complex for developers who want to deliver secure applications without a long learning curve.
+
+To address the need for correctness without complexity, DFINITY has designed its own Motoko programming language. Motoko provides a simple and expressive alternative to other programming languages that is easy to learn whether you are a new or experienced programmer.
+
+## Motivation and goals
+
+Motoko strives to be a simple and useful language for ICP smart contracts that uses a familiar syntax that incorporates the actor model. Motoko offers seamless integration for ICP features and makes the most out of WebAssembly's present and future functionalities.
+
+Motoko is not, and is not intended to be, the only language for implementing canister smart contracts. Canister development kits exist for Rust, TypeScript, Python, and soon Solidity. ICP's goal is to enable any language to be able to produce canister smart contracts by compiling the canister source code into WebAssembly.
+
+However, its tailored design means Motoko should be the easiest and safest language for coding on ICP.
+
+## Key design points
+
+Motoko provides many other developer productivity features. It has derived inspiration for its design from languages such as Java, JavaScript, C#, Swift, Pony, ML, and Haskell.
+
+Motoko syntax should be familiar to JavaScript programmers, but without the quirks of JavaScript.
+
+Motoko is a concurrent, actor-oriented language with convenient support for concurrency control using async/await and futures.
+Its core is a call-by-value, impure functional language with imperative and object-oriented features.
+
+Motoko is strongly typed and offers option types, records, variants, generics and subtyping. The type system is structural so that types with different names but equivalent definition are interchangeable; subtyping allows values to be used at their precise type but also at any more general supertype.
+
+- Motoko is safety-oriented. 
+- Memory management is automated using a garbage collector.
+- Implicit null values are avoided. Nulls must be handled explicitly using option types.
+- The type system cannot be circumvented using unsafe casts.
+- Arithmetic either uses unbounded integers that cannot overflow, or, when using bounded integers, employs checked arithmetic that faults on overflow.
+- All coercions between unrelated types are explicit.
+- Implicit promotion of a value to another type can only be achieved by subtyping, an operation with zero cost.
+- Motoko's support for concise, compiler-checked pattern matching encourages good coding style and auditable code.
+- Error-prone, object-oriented inheritance is not supported.
+
+Motoko canisters are compiled, not interpreted, producing small binaries with good performance.
+
+### Native canister smart contract support
+
+Motoko has native support for canister smart contracts, which are expressed as a Motoko actor. An actor is an autonomous object that fully encapsulates its state and communicates with other actors only through asynchronous messages.
+
+### Code sequentially in direct style
+
+On ICP, canisters can communicate with other canisters by sending asynchronous messages.
+
+Asynchronous programming is hard, so Motoko enables you to author asynchronous code in much simpler, sequential style. Asynchronous messages are function calls that return a future, and the `await` construct allows you to suspend execution until a future has completed.
+
+### Modern type system
+
+Motoko has been designed to be intuitive to those familiar with JavaScript and other popular languages, but offers modern features such as sound structural types, generics, variant types, and statically checked pattern matching.
+
+### Autogenerated IDL files
+
+A Motoko actor always presents a typed interface to its clients as a suite of named functions with argument and future result types.
+
+The Motoko compiler and IC SDK can emit this interface in a language neutral format called Candid, so other canisters, browser resident code and smart phone apps that support Candid can use the actor’s services. The Motoko compiler can consume and produce Candid files, allowing Motoko to seamlessly interact with canisters implemented in other programming languages, provided they also support Candid.
+
+### Orthogonal persistence
+
+ICP persists the memory and other state information of a canister as it is executed. Thus the state of a Motoko actor, including its in-memory data structures, survive indefinitely. Actor state does not need to be explicitly restored and saved to external storage.
+
+### Upgrades
+
+Motoko provides numerous features to help you leverage orthogonal persistence, including language features that allow you to retain a canister’s data as you upgrade the code of the canister.
+
+For example, Motoko lets you declare certain variables as `stable`. The values of `stable` variables are automatically preserved across canister upgrades.
+
+Once upgraded, the new interface is compatible with the previous one, meaning existing clients referencing the canister will continue to work, but new clients will be able to exploit its upgraded functionality. For more complex changes of any kind, Motoko provides a safe way of user-defined [explicit migration](../canister-maintenance/compatibility.md#explicit-migration).
+
+## Getting started
+
+Get started with Motoko by [setting up your developer environment](dev-env.md) and creating a simple [Hello, world!](quickstart.md) program.
+
+Logo
diff --git a/doc/md/getting-started/quickstart.md b/doc/md/getting-started/quickstart.md
new file mode 100644
index 00000000000..ea2f52183bb
--- /dev/null
+++ b/doc/md/getting-started/quickstart.md
@@ -0,0 +1,107 @@
+---
+sidebar_position: 4
+---
+
+
+# Motoko quickstart
+
+## Overview
+
+This quickstart guide showcases how to deploy a simple 'Hello, world!' Motoko smart contract.
+
+## Prerequisites
+
+Before getting started, assure you have set up your developer environment according to the instructions in the [developer environment guide](./dev-env).
+
+## Creating a new project
+
+Open a terminal window on your local computer, if you don’t already have one open.
+
+Create a new project and change to the project directory.
+
+Use `dfx new [project_name]` to create a new project:
+
+```
+dfx new hello_world
+```
+
+You will be prompted to select the language that your backend canister will use:
+
+```
+? Select a backend language: ›
+❯ Motoko
+Rust
+TypeScript (Azle)
+Python (Kybra)
+```
+
+Then, select a frontend framework for your frontend canister. In this example, select:
+
+```
+? Select a frontend framework: ›
+SvelteKit
+React
+Vue
+Vanilla JS
+No JS template
+❯ No frontend canister
+```
+
+Lastly, you can include extra features to be added to your project:
+
+```
+? Add extra features (space to select, enter to confirm) ›
+⬚ Internet Identity
+⬚ Bitcoin (Regtest)
+⬚ Frontend tests
+```
+
+## Smart contract code
+
+This hello world actor has a single function called `greet`. It is marked as `query` because it doesn't modify the state of the actor. The function accepts a name as input in type [`Text`](../base/Text.md) and returns a greeting of type [`Text`](../base/Text.md).
+
+
+```motoko title="src/hello_backend/main.mo"
+
+actor {
+  public query func greet(name : Text) : async Text {
+    return "Hello, " # name # "!";
+  };
+};
+```
+
+## Starting the deployment environment
+
+Start the Internet Computer for local development or check your connection to the Internet Computer for network deployment:
+- [Local deployment](/docs/current/developer-docs/getting-started/deploy-and-manage).
+- [Mainnet deployment](/docs/current/developer-docs/getting-started/deploy-and-manage).
+
+## Register, build, and deploy locally or on the mainnet
+
+To deploy locally, use the command:
+
+```
+dfx deploy
+```
+
+For deploying to the mainnet, use: `--network ic`.
+
+```
+dfx deploy --network 
+```
+
+## View your service or application in a browser, using the URLS in the output of the `dfx deploy` command:
+
+```
+...
+Committing batch.
+Committing batch with 18 operations.
+Deployed canisters.
+URLs:
+Frontend canister via browser
+        access_hello_frontend: http://127.0.0.1:4943/?canisterId=cuj6u-c4aaa-aaaaa-qaajq-cai
+Backend canister via Candid interface:
+        access_hello_backend: http://127.0.0.1:4943/?canisterId=cbopz-duaaa-aaaaa-qaaka-cai&id=ctiya-peaaa-aaaaa-qaaja-cai
+```
+
+Logo
diff --git a/doc/md/heartbeats.md b/doc/md/heartbeats.md
deleted file mode 100644
index 802f4477532..00000000000
--- a/doc/md/heartbeats.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# Heartbeats
-
-Internet Computer canisters can elect to receive regular heartbeat messages by exposing a particular `canister_heartbeat` function (see [heartbeat](https://smartcontracts.org/docs/interface-spec/index.html#heartbeat)).
-
-In Motoko, an actor can receive heartbeat messages by declaring a `system` function, named `heartbeat`, with no arguments, returning a future of unit type (`async ()`).
-
-A simple, contrived example is a recurrent alarm, that sends a message to itself every `n`-th heartbeat:
-
-``` motoko no-repl file=./examples/Alarm.mo
-```
-
-The `heartbeat` function, when declared, is called on every Internet Computer subnet *heartbeat*, by scheduling an asynchronous call to the `heartbeat` function. Due to its `async` return type, a heartbeat function may send further messages and await results. The result of a heartbeat call, including any trap or thrown error, is ignored. The implicit context switch inherent to calling every Motoko async function, means that the time the `heartbeat` body is executed may be later than the time the heartbeat was issued by the subnet.
-
-As an `async` function, `Alarm`'s `heartbeat` function is free to call other asynchronous functions (the inner call to `ring()` above is an example), as well as shared functions of other canisters.
diff --git a/doc/md/language-manual.md b/doc/md/language-manual.md
deleted file mode 100644
index b70985311f3..00000000000
--- a/doc/md/language-manual.md
+++ /dev/null
@@ -1,2524 +0,0 @@
-# Language quick reference
-
-
-
-This section serves as a technical reference for the previous chapters and has specific technical information for readers with specific interests. For example, this section provides technical details of interest to the following audiences:
-
--   Authors providing the higher-level documentation about the Motoko programming language.
-
--   Compiler experts interested in the details of Motoko and its compiler.
-
--   Advanced programmers who want to learn more about the lower-level details of Motoko.
-
-The language quick reference is intended to provide complete reference information about Motoko, but this section does *not* provide explanatory text or usage information. Therefore, this section is typically not suitable for readers who are new to programming languages or who are looking for a general introduction to using Motoko.
-
-Throughout, we use the term canister to refer to an Internet Computer canister smart contract.
-
-## Basic language syntax
-
-This section describes the basic language conventions you need to know for programming in Motoko.
-
-### Whitespace
-
-Space, newline, horizontal tab, carriage return, line feed and form feed are considered as whitespace. Whitespace is ignored but used to separate adjacent keywords, identifiers and operators.
-
-In the definition of some lexemes, the quick reference uses the symbol `␣` to denote a single whitespace character.
-
-### Comments
-
-Single line comments are all characters following `//` until the end of the same line.
-
-``` motoko
-// single line comment
-x = 1
-```
-
-Single or multi-line comments are any sequence of characters delimited by `/*` and `*/`:
-
-``` motoko
-/* multi-line comments
-   look like this, as in C and friends */
-```
-
-Comments delimited by `/*` and `*/` may be nested, provided the nesting is well-bracketed.
-
-``` motoko
-/// I'm a documentation comment
-/// for a function
-```
-
-Documentation comments start with `///` followed by a space until the end of line, and get attached to the definition immediately following them.
-
-Deprecation comments start with `/// @deprecated` followed by a space until the end of line, and get attached to the definition immediately following them. They are only recognized in front of `public` declarations.
-
-All comments are treated as whitespace.
-
-### Keywords
-
-The following keywords are reserved and may not be used as identifiers:
-
-``` bnf
-actor and assert async async* await await* break case catch class continue debug
-debug_show do else flexible false for from_candid func if ignore import
-in module not null object or label let loop private public query return
-shared stable switch system throw to_candid true try type var while with
-```
-
-### Identifiers
-
-Identifiers are alpha-numeric, start with a letter and may contain underscores:
-
-``` bnf
-   ::= Letter (Letter | Digit | _)*
-Letter ::= A..Z | a..z
-Digit  ::= 0..9
-```
-
-### Integers
-
-Integers are written as decimal or hexadecimal, `Ox`-prefixed natural numbers. Subsequent digits may be prefixed a single, semantically irrelevant, underscore.
-
-``` bnf
-digit ::= ['0'-'9']
-hexdigit ::= ['0'-'9''a'-'f''A'-'F']
-num ::= digit ('_'? digit)*
-hexnum ::= hexdigit ('_'? hexdigit)*
-nat ::= num | "0x" hexnum
-```
-
-Negative integers may be constructed by applying a prefix negation `-` operation.
-
-### Floats
-
-Floating point literals are written in decimal or `Ox`-prefixed hexadecimal scientific notation.
-
-``` bnf
-let frac = num
-let hexfrac = hexnum
-let float =
-    num '.' frac?
-  | num ('.' frac?)? ('e' | 'E') sign? num
-  | "0x" hexnum '.' hexfrac?
-  | "0x" hexnum ('.' hexfrac?)? ('p' | 'P') sign? num
-```
-
-The 'e' (or 'E') prefixes a base 10, decimal exponent; 'p' (or 'P') prefixes a base 2, binary exponent. In both cases, the exponent is in decimal notation.
-
-:::note
-
-the use of decimal notation, even for the base 2 exponent, is in keeping with the established hexadecimal floating point literal syntax of the `C` language.
-
-:::
-
-### Characters
-
-A character is a single quote (`'`) delimited:
-
--   Unicode character in UTF-8,
-
--   `\`-escaped newline, carriage return, tab, single or double quotation mark
-
--   `\`-prefixed ASCII character (TBR),
-
--   or `\u{` hexnum `}` enclosed valid, escaped Unicode character in hexadecimal (TBR).
-
-``` bnf
-ascii ::= ['\x00'-'\x7f']
-ascii_no_nl ::= ['\x00'-'\x09''\x0b'-'\x7f']
-utf8cont ::= ['\x80'-'\xbf']
-utf8enc ::=
-    ['\xc2'-'\xdf'] utf8cont
-  | ['\xe0'] ['\xa0'-'\xbf'] utf8cont
-  | ['\xed'] ['\x80'-'\x9f'] utf8cont
-  | ['\xe1'-'\xec''\xee'-'\xef'] utf8cont utf8cont
-  | ['\xf0'] ['\x90'-'\xbf'] utf8cont utf8cont
-  | ['\xf4'] ['\x80'-'\x8f'] utf8cont utf8cont
-  | ['\xf1'-'\xf3'] utf8cont utf8cont utf8cont
-utf8 ::= ascii | utf8enc
-utf8_no_nl ::= ascii_no_nl | utf8enc
-
-escape ::= ['n''r''t''\\''\'''\"']
-
-character ::=
-  | [^'"''\\''\x00'-'\x1f''\x7f'-'\xff']
-  | utf8enc
-  | '\\'escape
-  | '\\'hexdigit hexdigit
-  | "\\u{" hexnum '}'
-
-char := '\'' character '\''
-```
-
-### Text
-
-A text literal is `"`-delimited sequence of characters:
-
-``` bnf
-text ::= '"' character* '"'
-```
-
-### Literals
-
-``` bnf
- ::=                                     literals
-                                           natural
-                                         float
-                                          character
-                                          Unicode text
-```
-
-Literals are constant values. The syntactic validity of a literal depends on the precision of the type at which it is used.
-
-## Operators and types
-
-To simplify the presentation of available operators, operators and primitive types are classified into basic categories:
-
-| Abbreviation | Category   | Supported opertions             |
-| ------------ | ---------- | ------------------------------- |
-| A            | Arithmetic | arithmetic operations           |
-| L            | Logical    | logical/Boolean operations      |
-| B            | Bitwise    | bitwise and wrapping operations |
-| O            | Ordered    | comparison                      |
-| T            | Text       | concatenation                   |
-
-Some types have several categories. For example, type `Int` is both arithmetic (A) and ordered (O) and supports both arithmetic addition (`+`) and relational less than (`<`) (amongst other operations).
-
-### Unary operators
-
-| `` | Category |                  |
-| -------- | -------- | ---------------- |
-| `-`      | A        | numeric negation |
-| `+`      | A        | numeric identity |
-| `^`      | B        | bitwise negation |
-| `!`      |          | null break       |
-
-### Relational operators
-
-|           |          |                                                 |
-| --------- | -------- | ----------------------------------------------- |
-| `` | Category |                                                 |
-| `==`      |          | equals                                          |
-| `!=`      |          | not equals                                      |
-| `␣<␣`     | O        | less than *(must be enclosed in whitespace)*    |
-| `␣>␣`     | O        | greater than *(must be enclosed in whitespace)* |
-| `<=`      | O        | less than or equal                              |
-| `>=`      | O        | greater than or equal                           |
-
-Note that equality (`==`) and inequality (`!=`) do not have categories. Instead, equality and inequality are applicable to arguments of all *shared* types, including non-primitive, compound types such as immutable arrays, records, and variants.
-
-Equality and inequality are structural and based on the observable content of their operands (as determined by their static type).
-
-### Numeric binary operators
-
-| `` | Category |                |
-| --------- | -------- | -------------- |
-| `+`       | A        | addition       |
-| `-`       | A        | subtraction    |
-| `*`       | A        | multiplication |
-| `/`       | A        | division       |
-| `%`       | A        | modulo         |
-| `**`      | A        | exponentiation |
-
-### Bitwise and wrapping binary operators
-
-| `` | Category |                                                |
-| --------- | -------- | ---------------------------------------------- |
-| `&`       | B        | bitwise and                                    |
-| `\|`      | B        | bitwise or                                     |
-| `^`       | B        | exclusive or                                   |
-| `<<`      | B        | shift left                                     |
-| `␣>>`     | B        | shift right *(must be preceded by whitespace)* |
-| `<<>`     | B        | rotate left                                    |
-| `<>>`     | B        | rotate right                                   |
-| `+%`      | A        | addition (wrap-on-overflow)                    |
-| `-%`      | A        | subtraction (wrap-on-overflow)                 |
-| `*%`      | A        | multiplication (wrap-on-overflow)              |
-| `**%`     | A        | exponentiation (wrap-on-overflow)              |
-
-### Text operators
-
-| `` | Category |               |
-| --------- | -------- | ------------- |
-| `#`       | T        | concatenation |
-
-### Assignment operators
-
-| `:=`, `=`, `=` | Category |                                            |
-| --------------------------- | -------- | ------------------------------------------ |
-| `:=`                        | \*       | assignment (in place update)               |
-| `+=`                        | A        | in place add                               |
-| `-=`                        | A        | in place subtract                          |
-| `*=`                        | A        | in place multiply                          |
-| `/=`                        | A        | in place divide                            |
-| `%=`                        | A        | in place modulo                            |
-| `**=`                       | A        | in place exponentiation                    |
-| `&=`                        | B        | in place logical and                       |
-| `\|=`                       | B        | in place logical or                        |
-| `^=`                        | B        | in place exclusive or                      |
-| `<<=`                       | B        | in place shift left                        |
-| `>>=`                       | B        | in place shift right                       |
-| `<<>=`                      | B        | in place rotate left                       |
-| `<>>=`                      | B        | in place rotate right                      |
-| `+%=`                       | B        | in place add (wrap-on-overflow)            |
-| `-%=`                       | B        | in place subtract (wrap-on-overflow)       |
-| `*%=`                       | B        | in place multiply (wrap-on-overflow)       |
-| `**%=`                      | B        | in place exponentiation (wrap-on-overflow) |
-| `#=`                        | T        | in place concatenation                     |
-
-The category of a compound assignment `=`/`=` is given by the category of the operator ``/``.
-
-### Operator and keyword precedence
-
-The following table defines the relative precedence and associativity of operators and tokens, ordered from lowest to highest precedence. Tokens on the same line have equal precedence with the indicated associativity.
-
-| Precedence | Associativity | Token                                                                                                                         |
-| ---------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------- |
-| LOWEST     | none          | `if _ _` (no `else`), `loop _` (no `while`)                                                                                   |
-| (higher)   | none          | `else`, `while`                                                                                                               |
-| (higher)   | right         | `:=`, `+=`, `-=`, `*=`, `/=`, `%=`, `**=`, `#=`, `&=`, `\|=`, `^=`, `<<=`, `>>=`, `<<>=`, `<>>=`, `+%=`, `-%=`, `*%=`, `**%=` |
-| (higher)   | left          | `:`                                                                                                                           |
-| (higher)   | left          | `or`                                                                                                                          |
-| (higher)   | left          | `and`                                                                                                                         |
-| (higher)   | none          | `==`, `!=`, `<`, `>`, `<=`, `>`, `>=`                                                                                         |
-| (higher)   | left          | `+`, `-`, `#`, `+%`, `-%`                                                                                                     |
-| (higher)   | left          | `*`, `/`, `%`, `*%`                                                                                                           |
-| (higher)   | left          | `\|`                                                                                                                          |
-| (higher)   | left          | `&`                                                                                                                           |
-| (higher)   | left          | `^`                                                                                                                           |
-| (higher)   | none          | `<<`, `>>`, `<<>`, `<>>`                                                                                                      |
-| HIGHEST    | left          | `**`, `**%`                                                                                                                   |
-
-### Programs
-
-The syntax of a *program* `` is as follows:
-
-``` bnf
- ::=             programs
-  ;* ;*
-```
-
-A program is a sequence of imports `;*` followed by a sequence of declarations `;*` that ends with an optional actor or actor class declaration. The actor or actor class declaration determines the main actor, if any, of the program.
-
-For now, compiled programs must obey the following additional restrictions (not imposed on interpreted programs):
-
--   a `shared` function can only appear as a public field of an actor or actor class;
-
--   a program may contain at most one actor or actor class declaration, i.e. the final main actor or actor class; and
-
--   any main actor class declaration should be *anonymous*; if named, the class name should not be used as a value within the class and will be reported as an unavailable identifier.
-
-The last two restrictions are designed to forbid programmatic actor class recursion, pending compiler support.
-
-Note that the parameters (if any) of an actor class must have shared type (see [Sharability](#sharability)). The parameters of a program’s final actor class provide access to the corresponding canister installation argument(s); the Candid type of this argument is determined by the Candid projection of the Motoko type of the class parameter.
-
-### Imports
-
-The syntax of an *import* `` is as follows:
-
-``` bnf
- ::=                           imports
-  import  =? 
-
- ::=
-  ""                      import module from relative .mo
-  "mo:/"    import module from package
-  "canister:"           import external actor by 
-  "canister:"                 import external actor by 
-```
-
-An import introduces a resource referring to a local source module, module from a package of modules, or canister (imported as an actor). The contents of the resource are bound to ``.
-
-Though typically a simple identifier, ``, `` can also be any composite pattern binding selective components of the resource.
-
-The pattern must be irrefutable.
-
-### Libraries
-
-The syntax of a *library* (that can be referenced in an import) is as follows:
-
-``` bnf
- ::=                                               library
-  ;* module ?                          module
-  ;* ? actor class                       actor class
-     ?  (: )? 
-```
-
-A library `` is a sequence of imports `;*` followed by:
-
--   a named or anonymous (module) declaration; or
-
--   a named actor class declaration.
-
-Libraries stored in `.mo` files may be referenced by `import` declarations.
-
-In a module library, the optional name `?` is only significant within the library and does not determine the name of the library when imported. Instead, the imported name of a library is determined by the `import` declaration, giving clients of the library the freedom to choose library names (e.g. to avoid clashes).
-
-An actor class library, because it defines both a type constructor and a function with name ``, is imported as a module defining both a type and a function named ``. The name `` is mandatory and cannot be omitted. An actor class constructor is always asynchronous, with return type `async T` where `T` is the inferred type of the class body. Because actor construction is asynchronous, an instance of an imported actor class can only be created in an asynchronous context (i.e. in the body of a (non-`query`) `shared` function, asynchronous function, `async` expression or `async*` expression).
-
-### Declaration syntax
-
-The syntax of a *declaration* is as follows:
-
-``` bnf
- ::=                                                               declaration
-                                                                    expression
-  let  =                                                       immutable, trap on match failure
-  let  =  else                                   immutable, handle match failure
-  var  (: )? =                                             mutable
-   ? =?                                              object
-  ? func ? ?  (: )? =?        function
-  type  ? =                                         type
-  ? ? class                                            class
-    ? ?  (: )? 
-
- ::=           object body
-  { ;* }       field declarations
-
- ::=         class body
-  = ?      object body, optionally binding  to 'this' instance
-               object body
-```
-
-The syntax of a shared function qualifier with call-context pattern is as follows:
-
-``` bnf
- ::=
-  shared query? ?
-```
-
-For ``, an absent `?` is shorthand for the wildcard pattern `_`.
-
-``` bnf
- ::=                                object declaration fields
-  ? ?                            field
-
- ::=                                      field visibility
-  public
-  private
-  system
-
- ::=                                     field stability (actor only)
-  stable
-  flexible
-```
-
-The *visibility* qualifier `?` determines the accessibility of every field `` declared by ``:
-
--   An absent `?` qualifier defaults to `private` visibility.
-
--   Visibility `private` restricts access to `` to the enclosing object, module or actor.
-
--   Visibility `public` extends `private` with external access to `` using the dot notation `.`.
-
--   Visibility `system` extends `private` with access by the run-time system.
-
--   Visibility `system` *may only* appear on `func` declarations that are actor fields, and *must not* appear anywhere else.
-
-The *stability* qualifier `` determines the *upgrade* behaviour of actor fields:
-
--   A stability qualifier *should* appear on `let` and `var` declarations that are actor fields. An absent stability qualifier defaults to `flexible`.
-
--   `` qualifiers must not appear on fields of objects or modules.
-
--   The pattern in a `stable let  = ` declaration must be *simple* where, a pattern `pat` is simple if it (recursively) consists of
-
-    -   a variable pattern ``, or
-
-    -   an annotated simple pattern ` : `, or
-
-    -   a parenthesized simple pattern `(  )`.
-
-### Expression syntax
-
-The syntax of an *expression* is as follows:
-
-``` bnf
- ::=                                      expressions
-                                             variable
-                                            literal
-                                      unary operator
-                                binary operator
-                                binary relational operator
-  ( ,* )                                    tuple
-   .                                   tuple projection
-  ?                                         option injection
-  { ;* }                              object
-  {  (and )* (with ;+)? }   object combination/extension
-  # id ?                                    variant injection
-   .                                    object projection/member access
-   :=                                  assignment
-  =                                   unary update
-   =                            binary update
-  [ var? ,* ]                               array
-   [  ]                                array indexing
-  ? func                   function expression
-   ?                         function call
-  not                                       negation
-   and                                 conjunction
-   or                                  disjunction
-  if   (else )? conditional
-  switch  { (case  ;)+ } switch
-  while                       while loop
-  loop  (while )?             loop
-  for (  in  )           iteration
-  label  (: )?            label
-  break  ?                              break
-  continue                                   continue
-  return ?                                  return
-  async                            async expression
-  await                            await future (only in async)
-  async*                           delay an asynchronous computation
-  await*                           await a delayed computation (only in async)
-  throw                                     raise an error (only in async)
-  try  catch    catch an error (only in async)
-  assert                           assertion
-   :                                   type annotation
-                                            declaration
-  ignore                           ignore value
-  do                                      block as expression
-  do ?                                    option block
-   !                                        null break
-  debug                            debug expression
-  actor                                     actor reference
-  to_candid ( ,* )                          Candid serialization
-  from_candid                               Candid deserialization
-  (system  . )                          System actor class constructor
-  (  )                                      parentheses
-
- ::=
-  
-  
-
- ::=
-  { ;* }
-```
-
-### Patterns
-
-The syntax of a *pattern* is as follows:
-
-``` bnf
- ::=                                      patterns
-  _                                              wildcard
-                                             variable
-  ?                                   literal
-  ( ,* )                                    tuple or brackets
-  { ;* }                              object pattern
-  #  ?                                  variant pattern
-  ?                                         option
-   :                                   type annotation
-   or                                  disjunctive pattern
-
- ::=                                object pattern fields
-   (: ) =                          field
-   (: )                                 punned field
-```
-
-## Type syntax
-
-Type expressions are used to specify the types of arguments, constraints (a.k.a bounds) on type parameters, definitions of type constructors, and the types of sub-expressions in type annotations.
-
-``` bnf
- ::=                                     type expressions
-   ?                            constructor
-  ? { ;* }                     object
-  { ;* }                               variant
-  { # }                                         empty variant
-  [ var?  ]                                array
-  Null                                          null type
-  ?                                        option
-  ? ?  ->         function
-  async                                    future
-  async*                                   delayed, asynchronous computation
-  ( (( :)? ),* )                       tuple
-  Any                                           top
-  None                                          bottom
-   and                                intersection
-   or                                 union
-  Error                                         errors/exceptions
-  (  )                                      parenthesized type
-
- ::= (actor | module | object)
-
- ::=                                 shared function type qualifier
-  shared query?
-
- ::=                                   paths
-                                           type identifier
-   .                                 projection
-```
-
-An absent `?` abbreviates `object`.
-
-### Primitive types
-
-Motoko provides the following primitive type identifiers, including support for Booleans, signed and unsigned integers and machine words of various sizes, characters and text.
-
-The category of a type determines the operators (unary, binary, relational and in-place update via assignment) applicable to values of that type.
-
-| Identifier                         | Category | Description                                                            |
-| ---------------------------------- | -------- | ---------------------------------------------------------------------- |
-| [`Bool`](./base/Bool.md)           | L        | Boolean values `true` and `false` and logical operators                |
-| [`Char`](./base/Char.md)           | O        | Unicode characters                                                     |
-| [`Text`](./base/Text.md)           | T, O     | Unicode strings of characters with concatenation `_ # _` and iteration |
-| [`Float`](./base/Float.md)         | A, O     | 64-bit floating point values                                           |
-| [`Int`](./base/Int.md)             | A, O     | signed integer values with arithmetic (unbounded)                      |
-| [`Int8`](./base/Int8.md)           | A, O     | signed 8-bit integer values with checked arithmetic                    |
-| [`Int16`](./base/Int16.md)         | A, O     | signed 16-bit integer values with checked arithmetic                   |
-| [`Int32`](./base/Int32.md)         | A, O     | signed 32-bit integer values with checked arithmetic                   |
-| [`Int64`](./base/Int64.md)         | A, O     | signed 64-bit integer values with checked arithmetic                   |
-| [`Nat`](./base/Nat.md)             | A, O     | non-negative integer values with arithmetic (unbounded)                |
-| [`Nat8`](./base/Nat8.md)           | A, O     | non-negative 8-bit integer values with checked arithmetic              |
-| [`Nat16`](./base/Nat16.md)         | A, O     | non-negative 16-bit integer values with checked arithmetic             |
-| [`Nat32`](./base/Nat32.md)         | A, O     | non-negative 32-bit integer values with checked arithmetic             |
-| [`Nat64`](./base/Nat64.md)         | A, O     | non-negative 64-bit integer values with checked arithmetic             |
-| [`Blob`](./base/Blob.md)           | O        | binary blobs with iterators                                            |
-| [`Principal`](./base/Principal.md) | O        | principals                                                             |
-| [`Error`](./base/Error.md)         |          | (opaque) error values                                                  |
-
-Although many of these types have linguistic support for literals and operators, each primitive type also has an eponymous base library providing related functions and values (see [Motoko Base Library](./base-intro.md)). For example, the [`Text`](./base/Text.md) library provides common functions on `Text` values.
-
-### Type `Bool`
-
-The type `Bool` of category L (Logical) has values `true` and `false` and is supported by one and two branch `if _  (else )?`, `not `, `_ and _` and `_ or _` expressions. Expressions `if`, `and` and `or` are short-circuiting.
-
-
-
-### Type `Char`
-
-A `Char` of category O (Ordered) represents a character as a code point in the Unicode character set.
-
-Base library function `Char.toNat32(c)` converts a `Char` value, `c` to its `Nat32` code point. Function `Char.fromNat32(n)` converts a `Nat32` value, `n`, in the range *0x0..xD7FF* or *0xE000..0x10FFFF* of valid code points to its `Char` value; this conversion traps on invalid arguments. Function `Char.toText(c)` converts the `Char` `c` into the corresponding, single character `Text` value.
-
-### Type `Text`
-
-The type `Text` of categories T and O (Text, Ordered) represents sequences of Unicode characters (i.e. strings). Function `t.size` returns the number of characters in `Text` value `t`. Operations on text values include concatenation (`_ # _`) and sequential iteration over characters via `t.chars` as in `for (c : Char in t.chars()) { …​ c …​ }`.
-
-
-
-### Type `Float`
-
-The type `Float` represents 64-bit floating point values of categories A (Arithmetic) and O (Ordered).
-
-The semantics of `Float` and its operations is in accordance with standard [IEEE 754-2019](https://ieeexplore.ieee.org/document/8766229) (See [References](#references)).
-
-Common functions and values are defined in base library "base/Float".
-
-### Types `Int` and `Nat`
-
-The types `Int` and `Nat` are signed integral and natural numbers of categories A (Arithmetic) and O (Ordered).
-
-Both `Int` and `Nat` are arbitrary precision, with only subtraction `-` on `Nat` trapping on underflow.
-
-The subtype relation `Nat <: Int` holds, so every expression of type `Nat` is also an expression of type `Int` (but *not* vice versa). In particular, every value of type `Nat` is also a value of type `Int`, without change of representation.
-
-### Bounded integers `Int8`, `Int16`, `Int32` and `Int64`
-
-The types `Int8`, `Int16`, `Int32` and `Int64` represent signed integers with respectively 8, 16, 32 and 64 bit precision. All have categories A (Arithmetic), B (Bitwise) and O (Ordered).
-
-Operations that may under- or overflow the representation are checked and trap on error.
-
-The operations `+%`, `-%`, `*%` and `**%` provide access to wrap-around, modular arithmetic.
-
-As bitwise types, these types support bitwise operations *and* (`&`), *or* (`|`) and *exclusive-or* (`^`). Further, they can be rotated left (`<<>`), right (`<>>`), and shifted left (`<<`), right (`>>`). The right-shift preserves the two’s-complement sign. All shift and rotate amounts are considered modulo the numbers’s bit width *n*.
-
-Bounded integer types are not in subtype relationship with each other or with other arithmetic types, and their literals need type annotation if the type cannot be inferred from context, e.g. `(-42 : Int16)`.
-
-The corresponding module in the base library provides conversion functions: Conversion to `Int`, checked and wrapping conversions from `Int` and wrapping conversion to the bounded natural type of the same size.
-
-### Bounded naturals `Nat8`, `Nat16`, `Nat32` and `Nat64`
-
-The types `Nat8`, `Nat16`, `Nat32` and `Nat64` represent unsigned integers with respectively 8, 16, 32 and 64 bit precision. All have categories A (Arithmetic), B (Bitwise) and O (Ordered).
-
-Operations that may under- or overflow the representation are checked and trap on error.
-
-The operations `+%`, `-%`, `*%` and `**%` provide access to the modular, wrap-on-overflow operations.
-
-As bitwise types, these types support bitwise operations *and* (`&`), *or* (`|`) and *exclusive-or* (`^`). Further, they can be rotated left (`<<>`), right (`<>>`), and shifted left (`<<`), right (`>>`). The right-shift is logical. All shift and rotate amounts are considered modulo the number’s bit width *n*.
-
-The corresponding module in the base library provides conversion functions: Conversion to `Int`, checked and wrapping conversions from `Int` and wrapping conversion to the bounded natural type of the same size.
-
-### Type `Blob`
-
-The type `Blob` of category O (Ordered) represents binary blobs or sequences of bytes. Function `b.size` returns the number of characters in `Blob` value `b`. Operations on blob values include sequential iteration over bytes via function `b.vals` as in `for (v : Nat8 in b.vals()) { …​ v …​ }`.
-
-### Type `Principal`
-
-The type `Principal` of category O (Ordered) represents opaque principals such as canisters and users that can, for example, be used to identify callers of shared functions and used for simple authentication. Although opaque, principals may be converted to binary `Blob` values for more efficient hashing and other applications (see module `Principal` from the base library).
-
-### Error type
-
-Assuming base library import,
-
-``` motoko no-repl
-import E "mo:base/Error";
-```
-
-Errors are opaque values constructed and examined with operations:
-
--   `E.reject : Text -> Error`
-
--   `E.code : Error -> E.ErrorCode`
-
--   `E.message : Error -> Text`
-
-Type `E.ErrorCode` is equivalent to variant type:
-
-``` motoko no-repl
-type ErrorCode = {
-  // Fatal error.
-  #system_fatal;
-  // Transient error.
-  #system_transient;
-  // Destination invalid.
-  #destination_invalid;
-  // Explicit reject by canister code.
-  #canister_reject;
-  // Canister trapped.
-  #canister_error;
-  // Future error code (with unrecognized numeric code).
-  #future : Nat32;
-  // Error issuing inter-canister call
-  // (indicating destination queue full or freezing threshold crossed).
-  #call_error : { err_code : Nat32 }
-};
-```
-
-A constructed error `e = E.reject(t)` has `E.code(e) = #canister_reject` and `E.message(e) = t`.
-
-`Error` values can be thrown and caught within an `async` expression or `shared` function (only). See [Throw](#throw) and [Try](#try).
-
-Errors with codes other than `#canister_reject` (i.e. *system* errors) may be caught and thrown, but not user-constructed.
-
-:::note
-
-Exiting an async block or shared function with a non-`#canister-reject` system error exits with a copy of the error with revised code `#canister_reject` and the original `Text` message. This prevents programmatic forgery of system errors.
-
-:::
-
-:::note
-
-On the Internet Computer, the act of issuing a call to a canister function can fail, so that the call cannot (and will not be) performed.
-This can happen due to a lack of canister resources, typically because the local message queue for the destination canister is full,
-or because performing the call would reduce the current cycle balance of the calling canister to a level below its freezing threshold.
-Such call failures are reported by throwing an `Error` with code `#call_error { err_code = n }`, where `n` is the non-zero `err_code` value returned by the Internet Computer.
-Like other errors, call errors can be caught and handled using `try ... catch ...` expressions, if desired.
-
-:::
-
-### Constructed types
-
-` ?` is the application of a type identifier or path, either built-in (i.e. `Int`) or user defined, to zero or more type **arguments**. The type arguments must satisfy the bounds, if any, expected by the type constructor’s type parameters (see [Well-formed types](#well-formed-types)).
-
-Though typically a type identifier, more generally, `` may be a `.`-separated sequence of actor, object or module identifiers ending in an identifier accessing a type component of a value (for example, `Acme.Collections.List`).
-
-### Object types
-
-`? { ;* }` specifies an object type by listing its zero or more named *type fields*.
-
-Within an object type, the names of fields must be distinct (both by name and hash value).
-
-Object types that differ only in the ordering of the fields are equivalent.
-
-When `?` is `actor`, all fields have `shared` function type (specifying messages).
-
-### Variant types
-
-`{ ;* }` specifies a variant type by listing its variant type fields as a sequence of ``s.
-
-Within a variant type, the tags of its variants must be distinct (both by name and hash value).
-
-Variant types that differ only in the ordering of their variant type fields are equivalent.
-
-`{ # }` specifies the empty variant type.
-
-### Array types
-
-`[ var?  ]` specifies the type of arrays with elements of type ``.
-
-Arrays are immutable unless specified with qualifier `var`.
-
-### Null type
-
-The `Null` type has a single value, the literal `null`. `Null` is a subtype of the option `? T`, for any type `T`.
-
-### Option types
-
-`? ` specifies the type of values that are either `null` or a proper value of the form `? ` where `` has type ``.
-
-### Function types
-
-Type `? ?  -> ` specifies the type of functions that consume (optional) type parameters ``, consume a value parameter of type `` and produce a result of type ``.
-
-Both `` and `` may reference type parameters declared in ``.
-
-If `` or `` (or both) is a tuple type, then the length of that tuple type determines the argument or result arity of the function type.
-
-The optional `` qualifier specifies whether the function value is shared, which further constrains the form of ``, `` and `` (see [Sharability](#sharability) below).
-
-(Note that a `` function may itself be `shared` or `shared query`, determining the persistence of its state changes.)
-
-### Async types
-
-`async ` specifies a future producing a value of type ``.
-
-Future types typically appear as the result type of a `shared` function that produces an `await`-able value.
-
-### Async* types
-
-`async* ` specifies a delayed, asynchronous computation producing a value of type ``.
-
-Computation types typically appear as the result type of a `local` function that produces an `await*`-able value.
-
-(They cannot be used as the return types of `shared` functions.)
-
-### Tuple types
-
-`( (( :)? ),* )` specifies the type of a tuple with zero or more ordered components.
-
-The optional identifier ``, naming its components, is for documentation purposes only and cannot be used for component access. In particular, tuple types that differ only in the names of components are equivalent.
-
-The empty tuple type `()` is called the *unit type*.
-
-### Any type
-
-Type `Any` is the *top* type, i.e. the super-type of all types. All values have type `Any`.
-
-### None type
-
-Type `None` is the *bottom* type, a subtype of all other types. No value has type `None`.
-
-As an empty type, `None` can be used to specify the impossible return value of an infinite loop or unconditional trap.
-
-### Intersection type
-
-The type expression ` and ` denotes the syntactic *intersection* between its two type operands, that is, the greatest type that is a subtype of both. If both types are incompatible, the intersection is `None`.
-
-The intersection is *syntactic*, in that it does not consider possible instantiations of type variables. The intersection of two type variables is `None`, unless they are equal, or one is declared to be a (direct or indirect) subtype of the other.
-
-### Union type
-
-The type expression ` or ` denotes the syntactic *union* between its two type operands, that is, the smallest type that is a supertype of both. If both types are incompatible, the union is `Any`.
-
-The union is *syntactic*, in that it does not consider possible instantiations of type variables. The union of two type variables is the union of their bounds, unless the variables are equal, or one is declared to be a (direct or indirect) subtype of the other.
-
-### Parenthesized type
-
-A function that takes an immediate, syntactic tuple of length *n \>= 0* as its domain or range is a function that takes (respectively returns) *n* values.
-
-When enclosing the argument or result type of a function, which is itself a tuple type, `(  )` declares that the function takes or returns a single (boxed) value of type ``.
-
-In all other positions, `(  )` has the same meaning as ``.
-
-### Type fields
-
-``` bnf
- ::=                               object type fields
-   :                                   immutable value
-  var  :                               mutable value
-   ?  :             function value (short-hand)
-  type  ? =                type component
-```
-
-A type field specifies the name and type of a value field of an object, or the name and definition of a type component of an object. The value field names within a single object type must be distinct and have non-colliding hashes. The type component names within a single object type must also be distinct and have non-colliding hashes. Value fields and type components reside in separate name spaces and thus may have names in common.
-
-` : ` specifies an *immutable* field, named `` of type ``.
-
-`var  : ` specifies a *mutable* field, named `` of type ``.
-
-`type  ? = ` specifies a *type* component, with field name ``, abbreviating (parameterized) type ``.
-
-Unlike type declarations, a type component is not, in itself, recursive (though it may abbreviate an existing recursive type).
-In particular, the name `` is not bound in `` nor in any other fields of the enclosing object type. The name `` only determines the label to use when accessing the definition through a record of this type (using the dot notation).
-
-
-### Variant type fields
-
-``` bnf
- ::=                                 variant type fields
-  #  :                                 tag
-  #                                         unit tag (short-hand)
-```
-
-A variant type field specifies the tag and type of a single variant of an enclosing variant type. The tags within a single variant type must be distinct and have non-colliding hashes.
-
-`#  : ` specifies an (immutable) field, named `` of type ``. `# ` is sugar for an (immutable) field, named `` of type `()`.
-
-### Sugar
-
-When enclosed by an `actor` object type, ` ?  : ` is syntactic sugar for an immutable field named `` of `shared` function type `shared ?  → `.
-
-When enclosed by a non-`actor` object type, ` ?  : ` is syntactic sugar for an immutable field named `` of ordinary function type `?  → `.
-
-### Type parameters
-
-``` bnf
- ::=                              type parameters
-  < typ-param,* >
-
-   <:                                constrained type parameter
-                                          unconstrained type parameter
-```
-
-A type constructors, function value or function type may be parameterised by a vector of comma-separated, optionally constrained, type parameters.
-
-` <: ` declares a type parameter with constraint ``. Any instantiation of `` must subtype `` (at that same instantiation).
-
-Syntactic sugar `` declares a type parameter with implicit, trivial constraint `Any`.
-
-The names of type parameters in a vector must be distinct.
-
-All type parameters declared in a vector are in scope within its bounds.
-
-### Type arguments
-
-``` bnf
- ::=                                type arguments
-  < ,* >
-```
-
-Type constructors and functions may take type arguments.
-
-The number of type arguments must agree with the number of declared type parameters of the type constructor.
-
-For a function, the number of type arguments, when provided, must agree with the number of declared type parameters of the function’s type. Note that type arguments in function applications can typically be omitted and inferred by the compiler.
-
-Given a vector of type arguments instantiating a vector of type parameters, each type argument must satisfy the instantiated bounds of the corresponding type parameter.
-
-### Well-formed types
-
-A type `T` is well-formed only if (recursively) its constituent types are well-formed, and:
-
--   if `T` is `async U` then `U` is shared, and
-
--   if `T` is `shared query? U -> V`, `U` is shared and `V == ()` or `V == async W` with `W` shared, and
-
--   if `T` is `C` where:
-
-    -   a declaration `type C  = …​` is in scope, and
-
-    -   `Ti <: Ui[ T0/X0, …​, Tn/Xn ]`, for each `0 <= i <= n`.
-
--   if `T` is `actor { …​ }` then all fields in `…​` are immutable and have `shared` function type.
-
-### Subtyping
-
-Two types `T`, `U` are related by subtyping, written `T <: U`, whenever, one of the following conditions is true:
-
--   `T` equals `U` (reflexivity).
-
--   `U` equals `Any`.
-
--   `T` equals `None`.
-
--   `T` is a type parameter `X` declared with constraint `U`.
-
--   `T` is `Nat` and `U` is `Int`.
-
--   `T` is a tuple `(T0, …​, Tn)`, `U` is a tuple `(U0, …​, Un)`, and for each `0 <= i <= n`, `Ti <: Ui`.
-
--   `T` is an immutable array type `[ V ]`, `U` is an immutable array type `[ W ]` and `V <: W`.
-
--   `T` is a mutable array type `[ var V ]`, `U` is a mutable array type `[ var W ]` and `V == W`.
-
--   `T` is `Null` and `U` is an option type `? W` for some `W`.
-
--   `T` is `? V`, `U` is `? W` and `V <: W`.
-
--   `T` is a future `async V`, `U` is a future `async W`, and `V <: W`.
-
--   `T` is an object type ` { fts0 }`, `U` is an object type ` { fts1 }` and
-
-    -   `` == ``, and, for all fields,
-
-    -   if field `id : W` is in `fts1` then `id : V` is in `fts0` and `V <: W`, and
-
-    -   if mutable field `var id : W` is in `fts1` then `var id : V` is in `fts0` and `V == W`.
-
-        (That is, object type `T` is a subtype of object type `U` if they have same sort, every mutable field in `U` super-types the same field in `T` and every mutable field in `U` is mutable in `T` with an equivalent type. In particular, `T` may specify more fields than `U`.
-         Note that this clause defines subtyping for all sorts of object type, whether `module`, `object` or `actor`.)
-
--   `T` is a variant type `{ fts0 }`, `U` is a variant type `{ fts1 }` and
-
-    -   if field `# id : V` is in `fts0` then `# id : W` is in `fts1` and `V <: W`.
-
-        (That is, variant type `T` is a subtype of variant type `U` if every field of `T` subtypes the same field of `U`. In particular, `T` may specify fewer variants than `U`.)
-
--   `T` is a function type `?  T1 -> T2`, `U` is a function type `?  U1 -> U2` and
-
-    -   `T` and `U` are either both equivalently `?`, and
-
-    -   assuming constraints `X0 <: W0, …​, Xn <: Wn` then
-
-        -   for all `i`, `Wi == Vi`, and
-
-        -   `U1 <: T1`, and
-
-        -   `T2 <: U2`.
-
-            (That is, function type `T` is a subtype of function type `U` if they have same `?` qualification, they have the same type parameters (modulo renaming) and assuming the bounds in `U`, every bound in `T` supertypes the corresponding parameter bound in `U` (contra-variance), the domain of `T` supertypes the domain of `U` (contra-variance) and the range of `T` subtypes the range of `U` (co-variance).)
-
--   `T` (respectively `U`) is a constructed type `C` that is equal, by definition of type constructor `C`, to `W`, and `W <: U` (respectively `U <: W`).
-
--   For some type `V`, `T <: V` and `V <: U` (*transitivity*).
-
-### Sharability
-
-A type `T` is *shared* if it is
-
--   `Any` or `None`, or
-
--   a primitive type other than `Error`, or
-
--   an option type `? V` where `V` is shared, or
-
--   a tuple type `(T0, …​, Tn)` where all `Ti` are shared, or
-
--   an immutable array type `[V]` where `V` is shared, or
-
--   an `object` type where all fields are immutable and have shared type, or
-
--   a variant type where all tags have shared type, or
-
--   a shared function type, or
-
--   an `actor` type.
-
-### Stability
-
-Stability extends sharability to include mutable types. More precisely:
-
-A type `T` is *stable* if it is
-
--   `Any` or `None`, or
-
--   a primitive type other than `Error`, or
-
--   an option type `? V` where `V` is stable, or
-
--   a tuple type `(T0, …​, Tn)` where all `Ti` are stable, or
-
--   a (mutable or immutable) array type `[var? V]` where `V` is stable, or
-
--   an `object` type where all fields have stable type, or
-
--   a variant type where all tags have stable type, or
-
--   a shared function type, or
-
--   an `actor` type.
-
-This definition implies that every shared type is a stable type. The converse does not hold: there are types that are stable but not shared (notably types with mutable components).
-
-The types of actor fields declared with the `stable` qualifier must have stable type.
-
-The (current) value of such a field is preserved upon *upgrade*, whereas the values of other fields are reinitialized after an upgrade.
-
-## Static and dynamic semantics
-
-Below, we give a detailed account of the semantics of Motoko programs.
-
-For each [expression form](#expression-syntax) and each [declaration form](#declaration-syntax), we summarize its semantics, both in static terms (based on typing) and dynamic terms (based on program evaluation).
-
-### Programs
-
-A program `;* ;*` has type `T` provided:
-
--   `;*` has type `T` under the static environment induced by the imports in `;*`.
-
-All type and value declarations within `;*` are mutually-recursive.
-
-A program evaluates by (transitively) evaluating the imports, binding their values to the identifiers in `;*` and then evaluating the sequence of declarations in `;*`.
-
-### Libraries
-
-Restrictions on the syntactic form of modules means that libraries can have no side-effects.
-
-The imports of a library are local and not re-exported in its interface.
-
-Multiple imports of the same library can be safely deduplicated without loss of side-effects.
-
-#### Module libraries
-
-A library `;* module ? ` is a sequence of imports `;*` followed by a single module declaration.
-
-A library has module type `T` provided
-
--   `module ? ` has (module) type `T` under the static environment induced by the imports in `;*`.
-
-A module library evaluates by (transitively) evaluating its imports, binding their values to the identifiers in `;*` and then evaluating `module ? `.
-
-#### Actor class libraries
-
-The actor class library `;* ` where `` is of the form `? actor class  ?  (: )? ` has type:
-
-``` bnf
-module {
-  type  = T;
-   : (U1,...,Un) -> async T
-}
-```
-
-provided that:
-
--   the actor class declaration `` has function type `(U1, ...​, Un) -> async T` under the static environment induced by the imports in `;*`.
-
-Notice that the imported type of the function `` must be asynchronous.
-
-An actor class library evaluates by (transitively) evaluating its imports, binding their values to the identifiers in `;*`, and evaluating the (derived) module:
-
-``` bnf
-module {
-  
-}
-```
-
-On the Internet Computer, if this library is imported as identifier `Lib`, then calling `await Lib.(, ..., )`, installs a fresh instance of the actor class as an isolated IC canister, passing the values of ``, ...​, `` as installation arguments, and returns a reference to a (remote) actor of *type* `Lib.`, that is, `T`. Installation is (necessarily) asynchronous.
-
-
-#### Actor class management
-
-On the Internet Computer, the primary constructor of an imported actor class always creates a new principal and installs a fresh instance of the class as the code for that principal.
-While that is one way to install a canister on the IC, it is not the only way.
-
-To provide further control over the installation of actor classes, Motoko endows each imported actor class with an extra, secondary constructor, for use on the Internet Computer.
-This constructor takes an additional first argument that tailors the installation. The constructor is only available via special syntax that stresses its
-`system` functionality.
-
-Given some actor class constructor:
-
-``` motoko no-repl
-Lib. : (U1, ...​, Un) -> async T
-```
-
-Its secondary constructor is accessed as `(system Lib.)` with typing:
-
-``` motoko no-repl
-(system Lib.) :
-  { #new : CanisterSettings;
-    #install : Principal;
-    #reinstall : actor {} ;
-    #upgrade : actor {} }  ->
-    (U1, ...​, Un) -> async T
-```
-
-where
-
-``` motoko no-repl
-  type CanisterSettings = {
-     settings : ?{
-        controllers : ?[Principal];
-        compute_allocation : ?Nat;
-        memory_allocation : ?Nat;
-        freezing_threshold : ?Nat;
-     }
-  }
-```
-
-
-Calling `(system Lib.)()(, ...​, )` uses the first argument ``, a variant value, to control the installation of the canister further. Arguments `(, ..., )` are just the user-declared constructor arguments of types `U1, ..., Un` that would also be passed to the primary constructor.
-
-If `` is
-* `#new s`, where `s` has type `CanisterSettings`:
-  the call creates a fresh Internet Computer principal `p`, with settings `s`, and installs the instance to principal `p`.
-* `#install p`, where `p` has type `Principal`, the call installs the actor to an already created Internet Computer principal `p`. The principal must be empty (have no previously installed code) or the call will return an error.
-* `#upgrade a`, where `a` has type (or supertype) `actor {}`, the call installs the instance as an _upgrade_ of actor `a`, using its current stable storage to initialize stable variables and stable memory
-   of the new instance.
-* `#reinstall a`, where `a` has type (or supertype) `actor {}`, reinstalls the instance over the existing actor `a`, discarding its stable variables and stable memory.
-
-:::note
-
-On the Internet Computer, calling the primary constructor `Lib.` is equivalent to calling the secondary constructor `(system Lib.)` with argument `(#new {settings = null})` (i.e. using default settings).
-
-:::
-
-:::note
-
-On the Internet Computer, calls to `Lib.` and  `(system Lib.)(#new ...)` must be provisioned with enough cycles for the creation of a new principal. Other call variants will use the cycles of the already allocated principal or actor.
-
-:::
-
-:::danger
-
-The use of `#upgrade a` may be unsafe. Motoko will currently not verify that the upgrade is compatible with the code currently installed at `a`. (A future extension may verify compatibilty with a dynamic check.)
-
-The use of `#reinstall a` may be unsafe. Motoko cannot verify that the reinstall is compatible with the code currently installed in actor `a` (even with a dynamic check).
-A change in interface may break any existing clients of `a`. The current state of `a` will be lost.
-
-:::
-
-### Imports and Urls
-
-An import `import  =? ` declares a pattern `` bound to the contents of the text literal ``.
-
-`` is a text literal that designates some resource: a local library specified with a relative path, a named module from a named package, or an external canister, referenced either by numeric canister id or by a named alias, and imported as a Motoko actor.
-
-In detail, if `` is of the form:
-
--   `""` then `` is bound to the library module defined in file `.mo`. `` is interpreted relative to the absolute location of the enclosing file. Note the `.mo` extension is implicit and should *not* be included in ``. For example, `import U "lib/Util"` defines `U` to reference the module in local file `./lib/Util`.
-
--   `"mo:/"` then `` is bound to the library module defined in file `/.mo` in directory `` referenced by package alias ``. The mapping from `` to `` is determined by a compiler command-line argument `--package  `. For example, `import L "mo:base/List"` defines `L` to reference the `List` library in package alias `base`.
-
--   `"ic:"` then `` is bound to a Motoko actor whose Motoko type is determined by the canister’s IDL interface. The IDL interface of canister `` must be found in file `/.did`. The compiler assumes that `` is specified by command line argument `--actor-idl ` and that file `/.did` exists. For example, `import C "ic:lg264-qjkae"` defines `C` to reference the actor with canister id `lg264-qjkae` and IDL file `lg264-qjkae.did`.
-
--   `"canister:"` is a symbolic reference to canister alias ``. The compiler assumes that the mapping of `` to `` is specified by command line argument `--actor-alias  ic:`. If so, `"canister:"` is equivalent to `"ic:"` (see above). For example, `import C "canister:counter"` defines `C` to reference the actor otherwise known as `counter`.
-
-The case sensitivity of file references depends on the host operating system so it is recommended not to distinguish resources by filename casing alone.
-
-(Remark: when building multi-canister projects with the [IC SDK](https://internetcomputer.org/docs/current/developer-docs/setup/install), Motoko programs can typically import canisters by alias (e.g. `import C "canister:counter"`), without specifying low-level canister ids (e.g. `import C "ic:lg264-qjkae"`). The SDK tooling takes care of supplying the appropriate command-line arguments to the Motoko compiler.)
-
-(Remark: sensible choices for `` are identifiers, such as `Array`, or object patterns like `{ cons; nil = empty }`, which allow selective importing of individual fields, under original or other names.)
-
-### Declaration fields
-
-A declaration field `? ? ` defines zero or more fields of an actor or object, according to the set of variables defined by ``.
-
-Any identifier bound by a `public` declaration appears in the type of enclosing object, module or actor and is accessible via the dot notation.
-
-An identifier bound by a `private` or `system` declaration is excluded from the type of the enclosing object, module or actor and thus inaccessible.
-
-The declaration field has type `T` provided:
-
--   `` has type `T`;
-
--   if `?` is `stable` then `T` must be a stable type (see [Stability](#stability)).
-
-(Actor fields declared `flexible` (implicitly or explicitly) can have any type, but will not be preserved across upgrades.)
-
-Sequences of declaration fields are evaluated in order by evaluating their constituent declarations, with the following exception:
-
-During an upgrade only, the value of a `stable` declaration is obtained as follows:
-
--   if the stable declaration was previously declared stable in the retired actor, its initial value is inherited from the retired actor.
-
--   if the stable declaration was not declared stable in the retired actor, and is thus new, its value is obtained by evaluating ``.
-
-For an upgrade to be safe:
-
--   every stable identifier declared with type `T` in the retired actor and declared stable and of type `U` in the replacement actor, must satisfy `T <: U`.
-
-This condition ensures that every stable variable is either fresh, requiring initialization, or its value can be safely inherited from the retired actor. Note that stable variables may be removed across upgrades, or may simply be deprecated by an upgrade to type `Any`.
-
-#### System fields
-
-The declaration `` of a `system` field must be a manifest `func` declaration with one of the following names and types:
-
-| name          | type                                                          | description         |
-| ------------- | ------------------------------------------------------------- | ------------------- |
-| `heartbeat`   | `() -> async ()`                                              | heartbeat action    |
-| `timer`       | `(Nat64 -> ()) -> async ()`                                   | timer action        |
-| `inspect`     | `{ caller : Principal; msg : ; arg : Blob } -> Bool` | message predicate   |
-| `preupgrade`  | `() -> ()`                                                    | pre upgrade action  |
-| `postupgrade` | `() -> ()`                                                    | post upgrade action |
-
--   `heartbeat`, when declared, is called on every Internet Computer subnet **heartbeat**, scheduling an asynchronous call to the `heartbeat` function. Due to its `async` return type, a heartbeat function may send messages and await results. The result of a heartbeat call, including any trap or thrown error, is ignored. The implicit context switch means that the time the heartbeat body is executed may be later than the time the heartbeat was issued by the subnet.
-
--   `timer`, when declared, is called as a response of the canister global timer's expiration. The canister's global timer can be manipulated with the passed-in function argument of type `Nat64 -> ()` (taking an absolute time in nanoseconds) upon which libraries can build their own abstractions. When not declared (and in absence of the `-no-timer` flag), this system action is provided with default implementation by the compiler (additionally `setTimer` and `cancelTimer` are available as primitives).
-
--   `inspect`, when declared, is called as a predicate on every Internet Computer ingress message (with the exception of HTTP query calls). The return value, a `Bool`, indicates whether to accept or decline the given message. The argument type depends on the interface of the enclosing actor (see [Inspect](#inspect)).
-
--   `preupgrade`, when declared, is called during an upgrade, immediately *before* the (current) values of the (retired) actor’s stable variables are transferred to the replacement actor.
-
--   `postupgrade`, when declared, is called during an upgrade, immediately *after* the (replacement) actor body has initialized its fields (inheriting values of the retired actors' stable variables), and before its first message is processed.
-
-These `preupgrade` and `postupgrade` system methods provide the opportunity to save and restore in-flight data structures (e.g. caches) that are better represented using non-stable types.
-
-During an upgrade, a trap occurring in the implicit call to `preupgrade()` or `postupgrade()` causes the entire upgrade to trap, preserving the pre-upgrade actor.
-
-##### `inspect`
-
-Given a record of message attributes, this function produces a `Bool` that indicates whether to accept or decline the message by returning `true` or `false`. The function is invoked (by the system) on each ingress message (excluding non-replicated queries). Similar to a query, any side-effects of an invocation are transient and discarded. A call that traps due to some fault has the same result as returning `false` (message denial).
-
-The argument type of `inspect` depends on the interface of the enclosing actor. In particular, the formal argument of `inspect` is a record of fields of the following types:
-
--   `caller : Principal`: the principal, possibly anonymous, of the caller of the message;
-
--   `arg : Blob`: the raw, binary content of the message argument;
-
--   `msg : `: a variant of *decoding* functions, where ` == {…​; #: () → T; …​}` contains one variant per shared function, ``, of the actor. The variant’s tag identifies the function to be called; The variant’s argument is a function that, when applied, returns the (decoded) argument of the call as a value of type `T`.
-
-Using a variant, tagged with `#`, allows the return type, `T`, of the decoding function to vary with the argument type (also `T`) of the shared function ``.
-
-The variant’s argument is a function so that one can avoid the expense of message decoding (when appropriate).
-
-:::danger
-
-An actor that fails to declare system field `inspect` will simply accept all ingress messages.
-
-:::
-
-### Sequence of declarations
-
-A sequence of declarations `;*` occurring in a block, a program or embedded in the `;*` sequence of an object body has type `T` provided:
-
--   `;*` is empty and `T == ()`; or
-
--   `;*` is non-empty and:
-
--   all value identifiers bound by `;*` are distinct, and
-
--   all type identifiers bound by `;*` are distinct, and
-
--   under the assumption that each value identifier `` in `;*` has type `var_id? Tid`, and assuming the type definitions in `;*`:
-
--   each declaration in `;*` is well-typed, and
-
--   each value identifier `` in bindings produced by `;*` has type `var_id? Tid`, and
-
--   all but the last `` in `;*` of the form `` has type `()`;
-
--   the last declaration in `;*` has type `T`.
-
-Declarations in `;*` are evaluated sequentially. The first declaration that traps causes the entire sequence to trap. Otherwise, the result of the declaration is the value of the last declaration in `;*`. In addition, the set of value bindings defined by `;*` is the union of the bindings introduced by each declaration in `;*`.
-
-It is a compile-time error if any declaration in `;*` might require the value of an identifier declared in `;*` before that identifier’s declaration has been evaluated. Such *use-before-define* errors are detected by a simple, conservative static analysis not described here.
-
-### Patterns
-
-Patterns bind function parameters, declare identifiers and decompose values into their constituent parts in the cases of a `switch` expression.
-
-Matching a pattern against a value may *succeed*, *binding* the corresponding identifiers in the pattern to their matching values, or *fail*. Thus the result of a match is either a successful binding, mapping identifiers of the pattern to values, or failure.
-
-The consequences of pattern match failure depends on the context of the pattern.
-
--   In a function application or `let`-binding, failure to match the formal argument pattern or `let`-pattern causes a *trap*.
-
--   In a `case` branch of a `switch` expression, failure to match that case’s pattern continues with an attempt to match the next case of the switch, trapping only when no such case remains.
-
-### Wildcard pattern
-
-The wildcard pattern `_` matches a single value without binding its contents to an identifier.
-
-### Identifier pattern
-
-The identifier pattern `` matches a single value and binds it to the identifier ``.
-
-### Literal pattern
-
-The literal pattern `? ` matches a single value against the constant value of literal `` and fails if they are not (structurally) equal values.
-
-For integer literals only, the optional `` determines the sign of the value to match.
-
-### Tuple pattern
-
-The tuple pattern `( ,* )` matches a n-tuple value against an n-tuple of patterns (both the tuple and pattern must have the same number of items). The set of identifiers bound by each component of the tuple pattern must be distinct.
-
-The empty tuple pattern `()` is called the *unit pattern*.
-
-Pattern matching fails if one of the patterns fails to match the corresponding item of the tuple value. Pattern matching succeeds if every pattern matches the corresponding component of the tuple value. The binding returned by a successful match is the disjoint union of the bindings returned by the component matches.
-
-### Object pattern
-
-The object pattern `{ ;* }` matches an object value, a collection of named field values, against a sequence of named pattern fields. The set of identifiers bound by each field of the object pattern must be distinct. The names of the pattern fields in the object pattern must be distinct.
-
-Object patterns support *punning* for concision. A punned field `` is shorthand for ` = `; Similarly, a typed, punned field ` : ` is short-hand for ` =  : `. Both bind the matched value of the field named `` to the identifier ``.
-
-Pattern matching fails if one of the pattern fields fails to match the corresponding field value of the object value. Pattern matching succeeds if every pattern field matches the corresponding named field of the object value. The binding returned by a successful match is the union of the bindings returned by the field matches.
-
-The `` of the matched object type must be determined by an enclosing type annotation or other contextual type information.
-
-### Variant pattern
-
-The variant pattern `#  ?` matches a variant value (of the form `#  v`) against a variant pattern. An absent `?` is shorthand for the unit pattern (`()`). Pattern matching fails if the tag `` of the value is distinct from the tag `` of the pattern (i.e. `` \<\> ``); or the tags are equal but the value `v` does not match the pattern `?`. Pattern matching succeeds if the tag of the value is `` (i.e. `` = ``) and the value `v` matches the pattern `?`. The binding returned by a successful match is just the binding returned by the match of `v` against `?`.
-
-### Annotated pattern
-
-The annotated pattern ` : ` matches value of `v` type `` against the pattern ``.
-
-` : ` is *not* a dynamic type test, but is used to constrain the types of identifiers bound in ``, e.g. in the argument pattern to a function.
-
-### Option pattern
-
-The option `? ` matches a value of option type `? `.
-
-The match *fails* if the value is `null`. If the value is `? v`, for some value `v`, then the result of matching `? ` is the result of matching `v` against ``.
-
-Conversely, the `null` literal pattern may be used to test whether a value of option type is the value `null` and not `? v` for some `v`.
-
-### Or pattern
-
-The or pattern ` or ` is a disjunctive pattern.
-
-The result of matching ` or ` against a value is the result of matching ``, if it succeeds, or the result of matching ``, if the first match fails.
-
-(Note, statically, neither `` nor `` may contain identifier (``) patterns so a successful match always binds zero identifiers.)
-
-### Expression declaration
-
-The declaration `` has type `T` provided the expression `` has type `T` . It declares no bindings.
-
-The declaration `` evaluates to the result of evaluating `` (typically for ``'s side-effect).
-
-Note that if `` appears within a sequence of declarations, but not as the last declaration of that sequence, then `T` must be `()`.
-
-
-
-### Let declaration
-
-The `let` declaration `let  = ` has type `T` and declares the bindings in `` provided:
-
--   `` has type `T`, and
-
--   `` has type `T`.
-
-The declaration `let  = ` evaluates `` to a result `r`. If `r` is `trap`, the declaration evaluates to `trap`. If `r` is a value `v` then evaluation proceeds by matching the value `v` against ``. If matching fails, then the result is `trap`. Otherwise, the result is `v` and the binding of all identifiers in `` to their matching values in `v`.
-
-All bindings declared by a `let` (if any) are *immutable*.
-
-### Let-else declaration
-
-The `let-else` declaration `let  =  else ` has type `T` and declares the bindings in `` provided:
-
--   `` has type `T`,
-
--   `` has type `T`, and
-
--   `` has type `None`.
-
-The declaration `let  =  else ` evaluates `` to a result `r`.
-If `r` is `trap`, the declaration evaluates to `trap`.
-If `r` is a value `v` then evaluation proceeds by matching the value `v` against ``.
-If matching succeeds, the result is `v` and the binding of all identifiers in `` to their matching values in `v`.
-If matching fails, then evaluation continues with ``, which, having type `None`,
-cannot proceed to the end of the declaration but may still alter control-flow to,
-for example `return` or `throw` to exit an enclosing function,
-break` from an enclosing expression or simply diverge.
-
-All bindings declared by a `let-else` (if any) are *immutable*.
-
-#### Handling pattern match failures
-
-In the presence of refutable patterns, the pattern in a `let` declaration may fail to match the value of its expression.
-In such cases, the `let`-declaration will evaluate to a trap.
-The compiler emits a warning for any `let`-declaration than can trap due to pattern match failure.
-
-Instead of trapping, a user may want to explicitly handle pattern match failures.
-The `let-else` declaration, `let  =  else `, has mostly identical static and dynamic semantics to `let`,
-but diverts the program's control flow to `` when pattern matching fails, allowing recovery from failure.
-The `else` expression, ``, must have type `None` and typically exits the declaration using imperative control flow
-constructs such as `throw`, `return`, `break` or non-returning functions such as `Debug.trap(...)` (that all produce a result of type `None`).
-Any compilation warning that is produced for a `let` can be silenced by handling the potential pattern-match failure using `let-else`.
-
-### Var declaration
-
-The variable declaration `var  (: )? = ` declares a *mutable* variable `` with initial value ``. The variable’s value can be updated by assignment.
-
-The declaration `var ` has type `()` provided:
-
--   `` has type `T`; and
-
--   If the annotation `(:)?` is present, then `T` == ``.
-
-Within the scope of the declaration, `` has type `var T` (see [Assignment](#assignment)).
-
-Evaluation of `var  (: )? = ` proceeds by evaluating `` to a result `r`. If `r` is `trap`, the declaration evaluates to `trap`. Otherwise, the `r` is some value `v` that determines the initial value of mutable variable ``. The result of the declaration is `()` and `` is bound to a fresh location that contains `v`.
-
-### Type declaration
-
-The declaration `type  ? = ` declares a new type constructor ``, with optional type parameters `` and definition ``.
-
-The declaration `type C< X0 <: T0, …​, Xn <: Tn > = U` is well-formed provided:
-
--   type parameters `X0`, …​, `Xn` are distinct, and
-
--   assuming the constraints `X0 <: T0`, …​, `Xn <: Tn`:
-
--   constraints `T0`, …​, `Tn` are well-formed.
-
--   definition `U` is well-formed.
-
--   it is productive (see [Productivity](#productivity)).
-
--   it is non-expansive (see [Expansiveness](#expansiveness)).
-
-In scope of the declaration `type C< X0<:T0, …​, Xn <: Tn > = U`, any well-formed type `C< U0, …​, Un >` is equivalent to its expansion `U [ U0/X0, …​, Un/Xn ]`. Distinct type expressions that expand to identical types are inter-changeable, regardless of any distinction between type constructor names. In short, the equivalence between types is structural, not nominal.
-
-#### Productivity
-
-A type is *productive* if recursively expanding any outermost type constructor in its definition eventually produces a type other than the application of a type constructor.
-
-Motoko requires all type declarations to be productive.
-
-For example, the type definitions:
-
-``` motoko no-repl
-  type Person = { first : Text; last : Text };
-
-  type List = ?(T, List);
-
-  type Fst = T;
-
-  type Ok = Fst>;
-```
-
-are all productive and legal.
-
-But the type definitions,
-
-``` motoko no-repl
-  type C = C;
-
-  type D = D;
-
-  type E = F;
-  type F = E;
-
-  type G = Fst, Any>;
-```
-
-are all non-productive, since each definition will enter a loop after one or more expansions of its body.
-
-#### Expansiveness
-
-A set of mutually recursive type or class declarations will be rejected if the set is *expansive*.
-
-Expansiveness is a syntactic criterion. To determine whether a set of singly or mutually recursive type definitions, say
-
-``` motoko no-repl
-  type C<...,Xi,...> = T;
-  ...
-  type D<...,Yj,...> = U;
-```
-
-is expansive, construct a directed graph whose vertices are the formal type parameters (identified by position), `C#i`, with the following `{0,1}`-labeled edges:
-
--   For each occurrence of parameter `C#i` as immediate, `j`-th argument to type `D<…​,C#i,…​>`, add a *non-expansive*, `0`-labeled edge,`C#i -0-> D#j`.
-
--   For each occurrence of parameter `C#i` as a proper sub-expression of the `j`-th argument to type `D<…​,T[C#i],..>` add an *expansive* `1`-labeled edge, `C#i -1-> D#j`.
-
-The graph is expansive if, and only if, it contains a cycle with at least one expansive edge.
-
-For example, the type definition:
-
-``` motoko no-repl
-  type List = ?(T, List);
-```
-
-that recursively instantiates `List` at the same parameter `T`, is non-expansive and accepted, but the similar looking definition:
-
-``` motoko no-repl
-  type Seq = ?(T, Seq<[T]>);
-```
-
-that recursively instantiates `Seq` with a larger type, `[T]`, containing `T`, is *expansive* and rejected.
-
--   Type `List` is non-expansive because its graph, `{ List#0 -0-> List#0 }`, though cyclic, has no expansive edge.
-
--   Type `Seq`, on the other hand, is expansive, because its graph, `{ Seq#0 -1-> Seq#0 }`, has a cycle that includes an expansive edge.
-
-### Object declaration
-
-Declaration ` ? `, where `` is of the form `=? { ;* }`, declares an object with optional identifier `` and zero or more fields `;*`. Fields can be declared with `public` or `private` visibility; if the visibility is omitted, it defaults to `private`.
-
-The qualifier `` (one of `actor`, `module` or `object`) specifies the *sort* of the object’s type. The sort imposes restrictions on the types of the public object fields.
-
-Let `T =  { [var0] id0 : T0, …​ , [varn] idn : T0 }` denote the type of the object. Let `;*` be the sequence of declarations embedded in `;*`. The object declaration has type `T` provided that:
-
-1.  type `T` is well-formed for sort `sort`, and
-
-2.  under the assumption that ` : T`,
-
-    -   the sequence of declarations `;*` has type `Any` and declares the disjoint sets of private and public identifiers, `Id_private` and `Id_public` respectively, with types `T(id)` for `id` in `Id == Id_private union Id_public`, and
-
-    -   `{ id0, …​, idn } == Id_public`, and
-
-    -   for all `i in 0 <= i <= n`, `[vari] Ti == T(idi)`.
-
-3.  If `` is `module`, then the declarations in `;*` must be *static* (see [Static declarations](#static-declarations)).
-
-Note that requirement 1. imposes further constraints on the field types of `T`. In particular, if the sort is `actor` then:
-
--   all public fields must be non-`var` (immutable) `shared` functions (the public interface of an actor can only provide asynchronous messaging via shared functions);
-
-Because actor construction is asynchronous, an actor declaration can only occur in an asynchronous context (i.e. in the body of a (non-`query`) `shared` function, `async` expression or `async*` expression).
-
-Evaluation of `? ? =? { ;* }` proceeds by binding `` (if present), to the eventual value `v`, and evaluating the declarations in `;*`. If the evaluation of `;*` traps, so does the object declaration. Otherwise, `;*` produces a set of bindings for identifiers in `Id`. let `v0`, …​, `vn` be the values or locations bound to identifiers ``, …​, ``. The result of the object declaration is the object `v == sort {  = v1, …​,  = vn}`.
-
-If `?` is present, the declaration binds `` to `v`. Otherwise, it produces the empty set of bindings.
-
-:::danger
-
-Actor declaration is (implicitly) asynchronous and the state of the enclosing actor may change due to concurrent processing of other incoming actor messages. It is the programmer’s responsibility to guard against non-synchronized state changes.
-
-:::
-
-#### Static declarations
-
-A declaration is *static* if it is:
-
--   a `type` declaration, or
-
--   a `class` declaration, or
-
--   a `let` declaration with a static pattern and a static expression, or
-
--   a module, function or object declaration that desugars to a static `let` declaration, or
-
--   a static expression.
-
-An expression is *static* if it is:
-
--   a literal expression, or
-
--   a tuple of static expressions, or
-
--   an object of static expressions, or
-
--   a variant or option with a static expression, or
-
--   an immutable array, or
-
--   field access and projection from a static expression, or
-
--   a module expression, or
-
--   a function expression, or
-
--   a static declaration, or
-
--   an `ignore` of a static expression, or
-
--   a block, all of whose declarations are static, or
-
--   a type annotation with a static expression.
-
-A pattern is *static* if it is:
-
--   an identifier, or
-
--   a wildcard, or
-
--   a tuple of static patterns, or
-
--   type annotation with a static pattern.
-
-
-
-Static phrases are designed to be side-effect free, allowing the coalescing of duplicate library imports (a.k.a deduplication).
-
-### Function declaration
-
-The function declaration `? func ? ?  (: )? =? ` is syntactic sugar for a named `let` or anonymous declaration of a function expression.
-
-That is, when `?` is present and the function is named:
-
-``` bnf
-? func  ?  (: )? =?  :=
-  let  = ? func ?  (: )? =? 
-```
-
-But when `?` is absent and the function is anonymous:
-
-``` bnf
-? func ?  (: )? =?  :=
-  ? func ?  (: )? =? 
-```
-
-Named function definitions support recursion (a named function can call itself).
-
-:::note
-
-In compiled code, `shared` functions can only appear as public actor fields.
-
-:::
-
-### Class declaration
-
-The *class* declaration `? ? class ? ?  (: )? ` is sugar for pair of a type and function declaration:
-
-``` bnf
-? ? class  ?  (: )?  :=
-  type   =  { ;* };
-  ? func  ?  : async?   =
-    async?  ? 
-```
-
-where:
-
--   `?`, when present, requires `` == `actor`, and provides access to the `caller` of an `actor` constructor, and
-
--   `?` is the sequence of type identifiers bound by `?` (if any), and
-
--   `;*` is the set of public field types inferred from `;*`.
-
--   `` is the object body of ``.
-
--   `?` is the optional *this* (a.k.a *self*), parameter of ``.
-
--   `async?` is present, if only if, `` == `actor`.
-
-Note `?` must not be of the form `shared query ?`: a constructor, unlike a function, cannot be a query.
-
-An absent `?` defaults to `shared` when `sort` = `actor`.
-
-If `sort` is `actor`, then:
-
--   `?` must be absent or empty (`actor` classes cannot have type parameters);
-
--   ``'s type must be shared (see [Sharability](#sharability)).
-
--   `(: )?`, if present, must be of the form `: async T` for some actor type `T` (actor instantiation is asynchronous).
-
-If `(: )` is present, then the type `  {  ;* }` must be a subtype of the annotation ``. In particular, the annotation is used only to check, but not affect, the inferred type of function ``.
-
-The class declaration has the same type as function `` and evaluates to the function value ``.
-
-### Identifiers
-
-The identifier expression `` has type `T` provided `` is in scope, defined and declared with explicit or inferred type `T`.
-
-The expression `` evaluates to the value bound to `` in the current evaluation environment.
-
-### Literals
-
-A literal has type `T` only when its value is within the prescribed range of values of type `T`.
-
-The literal (or constant) expression `` evaluates to itself.
-
-### Unary operators
-
-The unary operator ` ` has type `T` provided:
-
--   `` has type `T`, and
-
--   The category of `` is a category of `T`.
-
-The unary operator expression ` ` evaluates `` to a result. If the result is a value `v`, it returns the result of ` v`. If the result is `trap`, the entire expression results in `trap`.
-
-### Binary operators
-
-The binary operator expression `  ` has type `T` provided:
-
--   `` has type `T`, and
-
--   `` has type `T`, and
-
--   The category of `` is a category of `T`.
-
-The binary operator expression `  ` evaluates `exp1` to a result `r1`. If `r1` is `trap`, the expression results in `trap`.
-
-Otherwise, `exp2` is evaluated to a result `r2`. If `r2` is `trap`, the expression results in `trap`.
-
-Otherwise, `r1` and `r2` are values `v1` and `v2` and the expression returns the result of `v1  v2`.
-
-### Relational operators
-
-The relational expression `  ` has type `Bool` provided:
-
--   `` has type `T`, and
-
--   `` has type `T`, and
-
--   `` is equality `==` or inequality `!=`, `T` is *shared*, and `T` is the least type such that `` and `` have type `T`;
-
--   the category O (Ordered) is a category of `T` and ``; or
-
-The binary operator expression `  ` evaluates `` to a result `r1`. If `r1` is `trap`, the expression results in `trap`.
-
-Otherwise, `exp2` is evaluated to a result `r2`. If `r2` is `trap`, the expression results in `trap`.
-
-Otherwise, `r1` and `r2` are values `v1` and `v2` and the expression returns the Boolean result of `v1  v2`.
-
-For equality and inequality, the meaning of `v1  v2` depends on the compile-time, static choice of `T` (not the run-time types of `v1` and `v2`, which, due to subtyping, may be more precise).
-
-### Tuples
-
-Tuple expression `(, …​, )` has tuple type `(T1, …​, Tn)`, provided ``, …​, `` have types `T1`, …​, `Tn`.
-
-The tuple expression `(, …​, )` evaluates the expressions `exp1` …​ `expn` in order, trapping as soon as some expression `` traps. If no evaluation traps and `exp1`, …​, `` evaluate to values `v1`,…​,`vn` then the tuple expression returns the tuple value `(v1, …​ , vn)`.
-
-The tuple projection ` . ` has type `Ti` provided `` has tuple type `(T1, …​, Ti, …​, Tn)`, `` == `i` and `1 <= i <= n`.
-
-The projection ` . ` evaluates `` to a result `r`. If `r` is `trap`, then the result is `trap`. Otherwise, `r` must be a tuple `(v1,…​,vi,…​,vn)` and the result of the projection is the value `vi`.
-
-The empty tuple expression `()` is called the *unit value*.
-
-### Option expressions
-
-The option expression `? ` has type `? T` provided `` has type `T`.
-
-The literal `null` has type `Null`. Since `Null <: ? T` for any `T`, literal `null` also has type `? T` and signifies the "missing" value at type `? T`.
-
-### Variant injection
-
-The variant injection `#  ` has variant type `{# id T}` provided:
-
--   `` has type `T`.
-
-The variant injection `# ` is just syntactic sugar for `#  ()`.
-
-The variant injection `#  ` evaluates `` to a result `r`. If `r` is `trap`, then the result is `trap`. Otherwise, `r` must be a value `v` and the result of the injection is the tagged value `#  v`.
-
-The tag and contents of a variant value can be tested and accessed using a [variant pattern](#variant-pattern).
-
-### Objects
-
-Objects can be written in literal form `{ ;* }`, consisting of a list of expression fields:
-
-``` bnf
- ::=                                object expression fields
-  var?  (: ) =                     field
-  var?  (: )                            punned field
-```
-
-Such an object literal, sometimes called a *record*, is equivalent to the object declaration `object { ;* }` where the declaration fields are obtained from the expression fields by prefixing each of them with `public let`, or just `public` in case of `var` fields. However, unlike declarations, the field list does not bind each `` as a local name within the literal, i.e., the field names are *not* in scope in the field expressions.
-
-Object expressions support *punning* for concision. A punned field `` is shorthand for ` = `; Similarly, a typed, punned field ` : ` is short-hand for ` =  : `. Both associate the field named `` with the value of the identifier ``.
-
-### Object combination/extension
-
-Objects can be combined and/or extended using the `and` and `with` keywords.
-
-A record expression `{  (and )* (with ;+)? }` merges the objects (or modules) specified as *base* expressions, and augments the result to also contain the specified fields. The `with ;+` clause can be omitted when at least two bases appear and none have common field labels.
-Thus the field list serves to:
-
--   disambiguate field labels occurring more than once in the bases,
--   define new fields,
--   override existing fields and their types, and
--   add new `var` fields
--   redefine existing `var` fields from some base to prevent aliasing.
-
-The resulting type is determined by the bases' (and explicitly given fields') static type.
-
-Any `var` field from some base must be overwritten in the explicit field list. This prevents introducing aliases of `var` fields.
-
-The record expression `{  and ...  with ; ... ; }` has type `T` provided:
-
--  The record `{ ; ... ; }` has record type `{ field_tys } == { var?  : U1; ... var?  : Um }`.
-
--  Let `newfields == {  , ...,  }` be the set of new field names.
-
--   Considering value fields:
-
-    -   Base expression `` has object or module type `sorti { field_tysi } == sorti { var?  : Ti1, …​, var?  : Tik }` where `sorti <> Actor`.
-
-    Let `fields(i) == { , ...,  }` be the set of static field names of base `i`. Then
-
-    -   `fields(i)` is disjoint from `newfields` (possibly by applying subtyping to the type of ``);
-    -   no field in `field_tysi` is a `var` field;
-    -  `fields(i)` is disjoint from `fields(j)` for `j < i`.
-
--   Considering type fields:
-
-    -   Base expression `` has object or module type `sorti { typ_fieldsi } == sorti { type  = … , …, type  = … }` where `sorti <> Actor`.
-    -   `typ_fieldsi` _agrees_ with `typ_fieldsj` for `j < i`.
-
--   `T` is `{ typ_fieldsi fields_tys1 ... typ_fieldsm fields_tysm field_tys }`.
-
-Here, two sequences of type fields _agree_ only when any two type fields of the same name in each sequence have equivalent definitions.
-
-
-
-The record expression `{  and ...  with ; ... ; }` evaluates records `` through `` and `{ exp-field1; ... ) = fi()` if `` is in `fields(i)`, for some `i`, or `f()` if `` is in `newfields`.
-
-### Object projection (member access)
-
-The object projection ` . ` has type `var? T` provided `` has object type `sort { var1?  : T1, …​, var?  : T, …​, var?  : Tn }` for some sort `sort`.
-
-The object projection ` . ` evaluates `` to a result `r`. If `r` is `trap`, then the result is `trap`. Otherwise, `r` must be an object value `{  = v1,…​, id = v, …​,  = vm }` and the result of the projection is the value `w` obtained from value or location `v` in field `id`.
-
-If `var` is absent from `var? T` then the value `w` is just the value `v` of immutable field ``, otherwise:
-
--   if the projection occurs as the target of an assignment expression then `w` is just `v`, the mutable location in field ``.
-
--   otherwise, `w` (of type `T`) is the value currently stored at the mutable location `v` in field ``.
-
-### Special member access
-
-The iterator access ` . ` has type `T` provided `` has type `U`, and `U`,`` and `T` are related by a row of the following table:
-
-|            |         |                         |                                              |
-| ---------- | ------- | ----------------------- | -------------------------------------------- |
-| U          | ``  | T                       | Description                                  |
-| `Text`     | `size`  | `Nat`                   | size (or length) in characters               |
-| `Text`     | `chars` | `{ next: () -> Char? }` | character iterator, first to last            |
-|            |         |                         |                                              |
-| `Blob`     | `size`  | `Nat`                   | size in bytes                                |
-| `Blob`     | `vals`  | `{ next: () -> Nat8? }` | byte iterator, first to last                 |
-|            |         |                         |                                              |
-| `[var? T]` | `size`  | `Nat`                   | number of elements                           |
-| `[var? T]` | `get`   | `Nat -> T`              | indexed read function                        |
-| `[var? T]` | `keys`  | `{ next: () -> Nat? }`  | index iterator, by ascending index           |
-| `[var? T]` | `vals`  | `{ next: () -> T? }`    | value iterator, by ascending index           |
-| `[var T]`  | `put`   | `(Nat, T) -> ()`        | indexed write function (mutable arrays only) |
-
-The projection ` . ` evaluates `` to a result `r`. If `r` is `trap`, then the result is `trap`. Otherwise, `r` must be a value of type `U` and the result of the projection is a value of type `T` whose semantics is given by the Description column of the previous table.
-
-:::note
-
-the `chars`, `vals`, `keys` and `vals` members produce stateful **iterator objects** than can be consumed by `for` expressions (see [For](#for)).
-
-:::
-
-### Assignment
-
-The assignment ` := ` has type `()` provided:
-
--   `` has type `var T`, and
-
--   `` has type `T`.
-
-The assignment expression ` := ` evaluates `` to a result `r1`. If `r1` is `trap`, the expression results in `trap`.
-
-Otherwise, `exp2` is evaluated to a result `r2`. If `r2` is `trap`, the expression results in `trap`.
-
-Otherwise `r1` and `r2` are (respectively) a location `v1` (a mutable identifier, an item of a mutable array or a mutable field of an object) and a value `v2`. The expression updates the current value stored in `v1` with the new value `v2` and returns the empty tuple `()`.
-
-### Unary compound assignment
-
-The unary compound assignment `= ` has type `()` provided:
-
--   `` has type `var T`, and
-
--   ``'s category is a category of `T`.
-
-The unary compound assignment `= ` evaluates `` to a result `r`. If `r` is `trap` the evaluation traps, otherwise `r` is a location storing value `v` and `r` is updated to contain the value ` v`.
-
-### Binary compound assignment
-
-The binary compound assignment ` = ` has type `()` provided:
-
--   `` has type `var T`, and
-
--   `` has type `T`, and
-
--   ``'s category is a category of `T`.
-
-For binary operator ``, the compound assignment expression ` = ` evaluates `` to a result `r1`. If `r1` is `trap`, the expression results in `trap`. Otherwise, `exp2` is evaluated to a result `r2`. If `r2` is `trap`, the expression results in `trap`.
-
-Otherwise `r1` and `r2` are (respectively) a location `v1` (a mutable identifier, an item of a mutable array or a mutable field of object) and a value `v2`. The expression updates the current value, `w` stored in `v1` with the new value `w  v2` and returns the empty tuple `()`.
-
-### Arrays
-
-The expression `[ var? ,* ]` has type `[var? T]` provided each expression `` in the sequence `,*` has type T.
-
-The array expression `[ var , …​,  ]` evaluates the expressions `exp0` …​ `expn` in order, trapping as soon as some expression `` traps. If no evaluation traps and `exp0`, …​, `` evaluate to values `v0`,…​,`vn` then the array expression returns the array value `[var? v0, …​ , vn]` (of size `n+1`).
-
-### Array indexing
-
-The array indexing expression ` [  ]` has type `var? T` provided:
-
--   `` has (mutable or immutable) array type `[var? T1]`.
-
-The expression ` [  ]` evaluates `exp1` to a result `r1`. If `r1` is `trap`, then the result is `trap`.
-
-Otherwise, `exp2` is evaluated to a result `r2`. If `r2` is `trap`, the expression results in `trap`.
-
-Otherwise, `r1` is an array value, `var? [v0, …​, vn]`, and `r2` is a natural integer `i`. If `i > n` the index expression returns `trap`.
-
-Otherwise, the index expression returns the value `v`, obtained as follows:
-
-If `var` is absent from `var? T` then the value `v` is the constant value `vi`.
-
-Otherwise,
-
--   if the indexing occurs as the target of an assignment expression then `v` is the `i`-th mutable location in the array;
-
--   otherwise, `v` is `vi`, the value currently stored in the `i`-th location of the array.
-
-### Function calls
-
-The function call expression ` ? ` has type `T` provided:
-
--   the function `` has function type `? < X0 <: V0, ..., Xn <: Vn > U1-> U2`; and
-
--   if `?` is absent but n > 0 then there exists minimal `T0, …​, Tn` (inferred by the compiler) such that:
-
--   each type argument satisfies the corresponding type parameter’s bounds: for each `1 <= i <= n`, `Ti <: [T0/X0, …​, Tn/Xn]Vi`; and
-
--   the argument `` has type `[T0/X0, …​, Tn/Xn]U1`, and
-
--   `T == [T0/X0, …​, Tn/Xn]U2`.
-
-The call expression ` ? ` evaluates `exp1` to a result `r1`. If `r1` is `trap`, then the result is `trap`.
-
-Otherwise, `exp2` is evaluated to a result `r2`. If `r2` is `trap`, the expression results in `trap`.
-
-Otherwise, `r1` is a function value, `? func   {  }` (for some implicit environment), and `r2` is a value `v2`. If `` is present and of the form `shared query? ` then evaluation continues by matching the record value `{caller = p}` against ``, where `p` is the `Principal` invoking the function (typically a user or canister). Matching continues by matching `v1` against ``. If pattern matching succeeds with some bindings, then evaluation returns the result of `` in the environment of the function value (not shown) extended with those bindings. Otherwise, some pattern match has failed and the call results in `trap`.
-
-:::note
-
-The exhaustiveness side condition on `shared` function expressions ensures that argument pattern matching cannot fail (see [Functions](#functions)).
-
-:::
-
-:::note
-
-Calls to local functions with `async` return type and `shared` functions can fail due to a lack of canister resources.
-Such failures will result in the call immediately throwing an error with  `code` `#call_error { err_code = n }`,
-where `n` is the non-zero `err_code` value returned by the Internet Computer.
-Earlier versions of Motoko would trap in such situations, making it difficult for the calling canister to mitigate such failures.
-Now, a caller can handle these errors using enclosing `try ... catch ...` expressions, if desired.
-
-:::
-
-### Functions
-
-The function expression `? func < X0 <: T0, …​, Xn <: Tn >  (: U2)? =? ` has type `? < X0 <: T0, ..., Xn <: Tn > U1-> U2` if, under the assumption that `X0 <: T0, …​, Xn <: Tn`:
-
--   `?` is of the form `shared query? ` if and only if `?` is `shared query?` (the `query` modifiers must agree);
-
--   all the types in `T0, …​, Tn` and `U2` are well-formed and well-constrained;
-
--   pattern `` has *context type* `{ caller : Principal }`;
-
--   pattern `` has type `U1`;
-
--   if the function is `shared` then `` and `` must be exhaustive;
-
--   expression `` has type return type `U2` under the assumption that `` has type `U1`.
-
-`? func ?  (: )? =? ` evaluates to a function value (a.k.a. closure), denoted `? func ?  = `, that stores the code of the function together with the bindings from the current evaluation environment (not shown) needed to evaluate calls to the function value.
-
-Note that a `` function may itself be `shared ` or `shared query `:
-
--   A `shared ` function may be invoked from a remote caller. Unless causing a trap, the effects on the callee persist beyond completion of the call.
-
--   A `shared query ` function may be also be invoked from a remote caller, but the effects on the callee are transient and discarded once the call has completed with a result (whether a value or error).
-
-In either case, `` provides access to a context value identifying the *caller* of the shared (query) function.
-
-:::note
-
-The context type is a record to allow extension with further fields in future releases.
-
-:::
-
-### Blocks
-
-The block expression `{ ;* }` has type `T` provided the last declaration in the sequence `;*` has type `T`. All identifiers declared in block must be distinct type identifiers or distinct value identifiers and are in scope in the definition of all other declarations in the block.
-
-The bindings of identifiers declared in `{ dec;* }` are local to the block.
-
-The type system ensures that a value identifier cannot be evaluated before its declaration has been evaluated, precluding run-time errors at the cost of rejection some well-behaved programs.
-
-Identifiers whose types cannot be inferred from their declaration, but are used in a forward reference, may require an additional type annotation (see [Annotated pattern](#annotated-pattern)) to satisfy the type checker.
-
-The block expression `{ ;* }` evaluates each declaration in `;*` in sequence (program order). The first declaration in `;*` that results in a trap causes the block to result in `trap`, without evaluating subsequent declarations.
-
-### Do
-
-The do expression `do ` allows the use of a block as an expression, in positions where the syntax would not directly allow a block.
-
-The expression `do ` has type `T` provided `` has type `T`.
-
-The `do` expression evaluates by evaluating `` and returning its result.
-
-### Option block
-
-The option block `do ? ` introduces scoped handling of null values.
-
-The expression `do ? ` has type `?T` provided `` has type `T`.
-
-The `do ? ` expression evaluates `` and returns its result as an optional value.
-
-Within `` the null break expression ` !` exits the nearest enclosing `do ?` block with value `null` whenever `` has value `null`, or continues evaluation with the contents of ``'s option value. (See [Null break](#null-break).)
-
-Option blocks nest with the target of a null break determined by the nearest enclosing option block.
-
-### Null break
-
-The null break expression ` !` invokes scoped handling of null values and returns the contents of an option value or changes control-flow when the value is `null`.
-
-It has type `T` provided:
-
--   the expression appears in the body, ``, of an enclosing option block of the form `do ? ` (see [Option block](#do-opt)).
-
--   `` has option type `? T`.
-
-The expression ` !` evaluates `` to a result `r`. If `r` is `trap`, then the result is `trap`; if `r` is `null`, execution breaks with value `null` from the nearest enclosing option block of form `do ? `; otherwise, `r` is `? v` and execution continues with value `v`.
-
-### Not
-
-The not expression `not ` has type `Bool` provided `` has type `Bool`.
-
-If `` evaluates to `trap`, the expression returns `trap`. Otherwise, `` evaluates to a Boolean value `v` and the expression returns `not v`, (the Boolean negation of `v`).
-
-### And
-
-The and expression ` and ` has type `Bool` provided `` and `` have type `Bool`.
-
-The expression ` and ` evaluates `exp1` to a result `r1`. If `r1` is `trap`, the expression results in `trap`. Otherwise `r1` is a Boolean value `v`. If `v == false` the expression returns the value `false` (without evaluating ``). Otherwise, the expression returns the result of evaluating ``.
-
-### Or
-
-The or expression ` or ` has type `Bool` provided `` and `` have type `Bool`.
-
-The expression ` and ` evaluates `exp1` to a result `r1`. If `r1` is `trap`, the expression results in `trap`. Otherwise `r1` is a Boolean value `v`. If `v == true` the expression returns the value `true` (without evaluating ``). Otherwise, the expression returns the result of evaluating ``.
-
-### If
-
-The expression `if   (else )?` has type `T` provided:
-
--   `` has type `Bool`
-
--   `` has type `T`
-
--   `` is absent and `() <: T`, or
-
--   `` is present and has type `T`.
-
-The expression evaluates `` to a result `r1`. If `r1` is `trap`, the result is `trap`. Otherwise, `r1` is the value `true` or `false`. If `r1` is `true`, the result is the result of evaluating ``. Otherwise, `r1` is `false` and the result is `()` (if `` is absent) or the result of `` (if `` is present).
-
-### Switch
-
-The switch expression `switch  { (case  ;)+ }` has type `T` provided:
-
--   `exp` has type `U`; and
-
--   for each case `case  ` in the sequence `(case  ;)+` :
-
--   pattern `` has type `U`; and,
-
--   expression `` has type `T`
-
-The expression evaluates `` to a result `r`. If `r` is `trap`, the result is `trap`. Otherwise, `r` is some value `v`. Let `case  ;` be the first case in `(case  ;)+` such that `` matches `v` for some binding of identifiers to values. Then result of the `switch` is the result of evaluating `` under that binding. If no case has a pattern that matches `v`, the result of the switch is `trap`.
-
-### While
-
-The expression `while  ` has type `()` provided:
-
--   `` has type `Bool`, and
-
--   `` has type `()`.
-
-The expression evaluates `` to a result `r1`. If `r1` is `trap`, the result is `trap`. Otherwise, `r1` is the value `true` or `false`. If `r1` is `true`, the result is the result of re-evaluating `while  `. Otherwise, the result is `()`.
-
-### Loop
-
-The expression `loop ` has type `None` provided `` has type `()`.
-
-The expression evaluates `` to a result `r1`. If `r1` is `trap`, the result is `trap`. Otherwise, the result is the result of (re-)evaluating `loop `.
-
-### Loop-while
-
-The expression `loop  while ` has type `()` provided:
-
--   `` has type `()`, and
-
--   `` has type `Bool`.
-
-The expression evaluates `` to a result `r1`. If `r1` is `trap`, the result is `trap`. Otherwise, evaluation continues with ``, producing result `r2`. If `r2` is `trap` the result is `trap`. Otherwise, if `r2` is `true`, the result is the result of re-evaluating `loop  while `. Otherwise, `r2` is false and the result is `()`.
-
-### For
-
-The iterator expression `for (  in  ) ` has type `()` provided:
-
--   `` has type `{ next : () → ?T }`,
-
--   pattern `` has type `T`, and
-
--   expression `` has type `()` (in the environment extended with the bindings of ``).
-
-The `for`-expression is syntactic sugar for
-
-``` bnf
-for (  in  )  :=
-  {
-    let x = ;
-    label l loop {
-      switch (x.next()) {
-        case (? ) ;
-        case (null) break l;
-      }
-    }
-  }
-```
-
-where `x` and `l` are fresh identifiers.
-
-In particular, the `for` loop will trap if evaluation of `` traps; as soon as `x.next()` traps, or the value of `x.next()` does not match pattern ``, or when `` traps.
-
-:::note
-
-Although general purpose, `for` loops are commonly used to consume iterators produced by [Special member access](#special-member-access) to, for example, loop over the indices (`a.keys()`) or values (`a.vals()`) of some array (here `a`).
-
-:::
-
-### Label
-
-The label-expression `label  (: )? ` has type `T` provided:
-
--   `(: )?` is absent and `T` is unit; or `(: )?` is present and `T == `;
-
--   `` has type `T` in the static environment extended with `label l : T`.
-
-The result of evaluating `label  (: )? ` is the result of evaluating ``.
-
-### Labeled loops
-
-If `` in `label  (: )? ` is a looping construct:
-
--   `while (exp2) `,
-
--   `loop  (while ())?`, or
-
--   `for ( in ) `
-
-the body, ``, of the loop is implicitly enclosed in `label  (…​)` allowing early continuation of the loop by the evaluation of expression `continue `.
-
-`` is fresh identifier that can only be referenced by `continue ` (through its implicit expansion to `break `).
-
-### Break
-
-The expression `break ` is equivalent to `break  ()`.
-
-The expression `break  ` has type `None` provided:
-
--   The label `` is declared with type `label  : T`.
-
--   `` has type `T`.
-
-The evaluation of `break  ` evaluates exp to some result `r`. If `r` is `trap`, the result is `trap`. If `r` is a value `v`, the evaluation abandons the current computation up to dynamically enclosing declaration `label  …​` using the value `v` as the result of that labelled expression.
-
-### Continue
-
-The expression `continue ` is equivalent to `break `, where `` is implicitly declared around the bodies of ``-labelled looping constructs (see [Labeled loops](#labeled-loops)).
-
-### Return
-
-The expression `return` is equivalent to `return ()`.
-
-The expression `return ` has type `None` provided:
-
--   `` has type `T` and
-
--   `T` is the return type of the nearest enclosing function (with no intervening `async` expression), or
-
--   `async T` is the type of the nearest enclosing (perhaps implicit) `async` expression (with no intervening function declaration)
-
-The `return` expression exits the corresponding dynamic function invocation or completes the corresponding dynamic `async` or `async*` expression with the result of ``.
-
-### Async
-
-The async expression `async ` has type `async T` provided:
-
--   `` has type `T`;
-
--   `T` is shared.
-
-Any control-flow label in scope for `async ` is not in scope for ``. However, `` may declare and use its own, local, labels.
-
-The implicit return type in `` is `T`. That is, the return expression, ``, (implicit or explicit) to any enclosed `return ?` expression, must have type `T`.
-
-Evaluation of `async ` queues a message to evaluate `` in the nearest enclosing or top-level actor. It immediately returns a future of type `async T` that can be used to `await` the result of the pending evaluation of ``.
-
-:::note
-
-Because it involves messaging, evaluating an `async` expression can fail due to a lack of canister resources.
-Such failures will result in the call immediately throwing an error with  `code` `#call_error { err_code = n }`,
-where `n` is the non-zero `err_code` value returned by the Internet Computer.
-Earlier version of Motoko would trap in such situations, making it difficult for the producer of the async expression to mitigate such failures.
-Now, the producer can handle these errors using an enclosing `try ... catch ...` expression, if desired.
-
-:::
-
-
-### Await
-
-The `await` expression `await ` has type `T` provided:
-
--   `` has type `async T`,
-
--   `T` is shared,
-
--   the `await` is explicitly enclosed by an `async`-expression or appears in the body of a `shared` function.
-
-Expression `await ` evaluates `` to a result `r`. If `r` is `trap`, evaluation returns `trap`. Otherwise `r` is a future. If the `future` is incomplete, that is, its evaluation is still pending, `await ` suspends evaluation of the neared enclosing `async` or `shared`-function, adding the suspension to the wait-queue of the `future`. Execution of the suspension is resumed once the future is completed (if ever). If the future is complete with value `v`, then `await ` suspends evaluation and schedules resumption of execution with value `v`. If the future is complete with (thrown) error value `e`, then `await ` suspends evaluation and schedules resumption of execution by re-throwing the error `e`.
-
-Note: suspending computation on `await`, regardless of the dynamic status of the future, ensures that all tentative state changes and message sends prior to the `await` are committed and irrevocable.
-
-:::danger
-
-Between suspension and resumption of a computation, the state of the enclosing actor may change due to concurrent processing of other incoming actor messages. It is the programmer’s responsibility to guard against non-synchronized state changes.
-
-Using `await` signals that the computation *will* commit its current state and suspend execution.
-
-:::
-
-:::note
-
-Because it involves additional messaging, an `await` on a completed future can, in rare circumstances, fail due to a lack of canister resources.
-Such failures will result in the call immediately throwing an error with `code` `#call_error { err_code = n }`,
-where `n` is the non-zero `err_code` value returned by the Internet Computer
-The error is produced eagerly, without suspending nor committing state.
-Earlier versions of Motoko would trap in such situations, making it difficult for the consumer of the `await` to mitigate such failures.
-Now, the consumer can handle these errors by using an enclosing `try ... catch ...` expression, if desired.
-
-:::
-
-
-### Async*
-
-The async expression `async* ` has type `async* T` provided:
-
--   `` has type `T`;
-
--   `T` is shared.
-
-Any control-flow label in scope for `async* ` is not in scope for ``. However, `` may declare and use its own, local, labels.
-
-The implicit return type in `` is `T`. That is, the return expression, ``, (implicit or explicit) to any enclosed `return ?` expression, must have type `T`.
-
-Evaluation of `async* ` produces a delayed computation to evaluate ``. It immediately returns a value of type `async* T`.
-The delayed computation can be executed using `await*`, producing one evaluation
-of the computation ``.
-
-:::danger
-
-Note that `async ` has the effect of scheduling a single asynchronous computation of ``, regardless of whether its result, a future, is consumed with an `await`.
-Moreover, each additional consumption by an `await` just returns the previous result, without repeating the computation.
-
-In comparison, `async* `,  has *no effect* until its value is consumed by an `await*`.
-Moreover, each additional consumption by an `await*` will trigger a new evaluation of ``, including repeated effects.
-
-Be careful of this distinction, and other differences, when refactoring code.
-
-:::
-
-:::note
-
-The `async*` and corresponding `await*` constructs are useful for efficiently abstracting asynchronous code into re-useable functions.
-In comparison, calling a local function that returns a proper `async` type requires committing state and suspending execution with each `await` of its result, which can be undesirable.
-
-:::
-
-
-### Await*
-
-The `await*` expression `await* ` has type `T` provided:
-
--   `` has type `async* T`,
-
--   `T` is shared,
-
--   the `await*` is explicitly enclosed by an `async`-expression or appears in the body of a `shared` function.
-
-Expression `await* ` evaluates `` to a result `r`. If `r` is `trap`, evaluation returns `trap`. Otherwise `r` is a delayed computation ``. The evaluation of `await* ` proceeds with the evaluation of ``, executing the delayed computation.
-
-:::danger
-
-During the evaluation of ``, the state of the enclosing actor may change due to concurrent processing of other incoming actor messages. It is the programmer’s responsibility to guard against non-synchronized state changes.
-
-:::
-
-:::note
-
-Unlike `await`, which, regardless of the dynamic status of the future, ensures that all tentative state changes and message sends prior to the `await` are committed and irrevocable, `await*` does not, in itself, commit any state changes, nor does it suspend computation.
-Instead, evaluation proceeds immediately according to `` (the value of ``), committing state and suspending execution whenever `` does (but not otherwise).
-
-:::
-
-:::note
-
-Evaluation of a delayed `async*` block is synchronous while possible, switching to asynchronous when necessary due to a proper `await`.
-
-Using `await*` signals that the computation *may* commit state and suspend execution during the evaluation of ``, that is, that evaluation of `` may perform zero or more proper `await`s and may be interleaved with the execution of other, concurrent messages.
-
-:::
-
-### Throw
-
-The `throw` expression `throw ` has type `None` provided:
-
--   `` has type `Error`,
-
--   the `throw` is explicitly enclosed by an `async`-expression or appears in the body of a `shared` function.
-
-Expression `throw ` evaluates `` to a result `r`. If `r` is `trap`, evaluation returns `trap`. Otherwise `r` is an error value `e`. Execution proceeds from the `catch` clause of the nearest enclosing `try  catch  ` whose pattern `` matches value `e`. If there is no such `try` expression, `e` is stored as the erroneous result of the `async` value of the nearest enclosing `async`, `async*` expression or `shared` function invocation.
-
-### Try
-
-The `try` expression `try  catch  ` has type `T` provided:
-
--   `` has type `T`,
-
--   `` has type `Error` and `` has type `T` in the context extended with ``, and
-
--   the `try` is explicitly enclosed by an `async`-expression or appears in the body of a `shared` function.
-
-Expression `try  catch  ` evaluates `` to a result `r`. If evaluation of `` throws an uncaught error value `e`, the result of the `try` is the result of evaluating `` under the bindings determined by the match of `e` against `pat`.
-
-:::note
-
-Because the `Error` type is opaque, the pattern match cannot fail (typing ensures that `` is an irrefutable wildcard or identifier pattern).
-
-:::
-
-See [Error type](#error-type).
-
-### Assert
-
-The assert expression `assert ` has type `()` provided `` has type `Bool`.
-
-Expression `assert ` evaluates `` to a result `r`. If `r` is `trap` evaluation returns `trap`. Otherwise `r` is a Boolean value `v`. The result of `assert ` is:
-
--   the value `()`, when `v` is `true`; or
-
--   `trap`, when `v` is `false`.
-
-### Type annotation
-
-The type annotation expression ` : ` has type `T` provided:
-
--   `` is `T`, and
-
--   `` has type `U` where `U <: T`.
-
-Type annotation may be used to aid the type-checker when it cannot otherwise determine the type of `` or when one wants to constrain the inferred type, `U` of `` to a less-informative super-type `T` provided `U <: T`.
-
-The result of evaluating ` : ` is the result of evaluating ``.
-
-:::note
-
-Type annotations have no-runtime cost and cannot be used to perform the (checked or unchecked) `down-casts` available in other object-oriented languages.
-
-:::
-
-### Candid Serialization
-
-The *Candid serialization* expression `to_candid ( ,*)` has type `Blob` provided:
-
--   `(,*)` has type `(T1,…​,Tn)`, and each `Ti` is *shared*.
-
-Expression `to_candid ( ,* )` evaluates the expression sequence `( ,* )` to a result `r`. If `r` is `trap`, evaluation returns `trap`. Otherwise, `r` is a sequence of Motoko values `vs`. The result of evaluating `to_candid ( ,* )` is some Candid blob `b = encode((T1,...,Tn))(vs)`, encoding `vs`.
-
-The Candid *deserialization* expression `from_candid ` has type `?(T1,…​,Tn)` provided:
-
--   `?(T1,…​,Tn)` is the expected type from the context;
-
--   `` has type `Blob`; and
-
--   `?(T1,…​,Tn)` is *shared*.
-
-Expression `from_candid ` evaluates `` to a result `r`. If `r` is `trap`, evaluation returns `trap`. Otherwise `r` is a binary blob `b`. If `b` Candid-decodes to Candid value sequence `Vs` of type `ea((T1,...,Tn))` then the result of `from_candid` is `?v` where `v = decode((T1,...,Tn))(Vs)`. If `b` Candid-decodes to a Candid value sequence `Vs` that is not of Candid type `ea((T1,...,Tn))` (but well-formed at some other type) then the result is `null`. If `b` is not the encoding of any well-typed Candid value, but some arbitrary binary blob, then the result of `from_candid` is a trap.
-
-(Informally, here `ea(_)` is the Motoko-to-Candid type sequence translation and `encode/decode((T1,...,Tn))(_)` are type-directed Motoko-Candid value translations.)
-
-
-
-:::note
-
-Operation `from_candid` returns `null` when the argument is a valid Candid encoding of the wrong type. It traps if the blob is not a valid Candid encoding at all.
-
-:::
-
-:::note
-
-Operations `to_candid` and `from_candid` are syntactic operators, not first-class functions, and must be fully applied in the syntax.
-
-:::
-
-:::danger
-
-The Candid encoding of a value as a blob is not unique and the same value may have many different Candid representations as a blob. For this reason, blobs should never be used to, for instance, compute hashes of values or determine equality, whether across compiler versions or even just different programs.
-
-:::
-
-### Declaration
-
-The declaration expression `` has type `T` provided the declaration `` has type `T`.
-
-Evaluating the expression `` proceeds by evaluating ``, returning the result of `` but discarding the bindings introduced by `` (if any).
-
-(The expression `` is actually shorthand for the block expression `{  }`.)
-
-### Ignore
-
-The expression `ignore ` has type `()` provided the expression `` has type `Any` .
-
-The expression `ignore ` evaluates `` (typically for some side-effect) but discards its value.
-
-`Ignore` is useful for evaluating an expression within a sequence of declarations when that expression has non-`unit` type (and the simpler `` declaration would be ill-typed). Then the semantics is equivalent to `let _ =  : Any`.
-
-### Debug
-
-The debug expression `debug ` has type `()` provided the expression `` has type `()`.
-
-When the program is compiled or interpreted with (default) flag `--debug`, evaluating the expression `debug ` proceeds by evaluating ``, returning the result of ``.
-
-When the program is compiled or interpreted with flag `--release`, evaluating the expression `debug ` immediately returns the unit value `()`. The code for `` is never executed, nor is its code included in the compiled binary.
-
-### Actor references
-
-The actor reference `actor ` has expected type `T` provided:
-
--   the expression is used in a context expecting an expression of type `T` (typically as the subject of a type annotation, typed declaration or function argument); and
-
--   `T` is an some actor type `actor { …​ }`; and
-
--   `` has type `Text`.
-
-The argument `` must be, or evaluate to, the textual format of an IC canister identifier (specified elsewhere), otherwise the expression traps. The result of the expression is an actor value representing that canister.
-
-The validity of the canister identifier and its asserted type `T` are promises and taken on trust.
-
-An invalid canister identifier or type may manifest itself, if at all, as a later dynamic failure when calling a function on the actor’s proclaimed interface, which will either fail or be rejected.
-
-:::note
-
-The argument to `actor` should *not* include the `ic:` resource locator used to specify an `import`. For example, use `actor "lg264-qjkae"`, not `actor "ic:lg264-qjkae"`.
-
-:::
-
-:::danger
-
-Although they do not compromise type safety, actor references can easily introduce latent, dynamic errors. Accordingly, actor references should be used sparingly and only when needed.
-
-:::
-
-### Parentheses
-
-The parenthesized expression `(  )` has type `T` provided `` has type `T`.
-
-The result of evaluating `(  )` is the result of evaluating ``.
-
-### Subsumption
-
-Whenever `` has type `T` and `T <: U` (`T` subtypes `U`) then by virtue of *implicit subsumption*, `` also has type `U` (without extra syntax).
-
-In general, this means that an expression of a more specific type may appear wherever an expression of a more general type is expected, provided the specific and general types are related by subtyping. This static change of type has no runtime cost.
-
-## References
-
--   *IEEE Standard for Floating-Point Arithmetic*, in IEEE Std 754-2019 (Revision of IEEE 754-2008), vol., no., pp.1-84, 22 July 2019, doi: 10.1109/IEEESTD.2019.8766229.
diff --git a/doc/md/local-objects-classes.md b/doc/md/local-objects-classes.md
deleted file mode 100644
index cf080f804b2..00000000000
--- a/doc/md/local-objects-classes.md
+++ /dev/null
@@ -1,348 +0,0 @@
-# Local objects and classes
-
-
-
-In Motoko, an `object` may encapsulate local state (`var`-bound variables) by packaging this state with `public` methods that access and update it.
-
-As in other typed languages, Motoko programs benefit from the ability to encapsulate state as objects with abstract types.
-
-However, Motoko objects that include mutable state are *not shareable*, and this is a critical security-oriented design decision.
-
-If they were shareable, that would mean either conceptually moving a mobile object’s code among actors and executing it remotely, a security risk, or sharing state with remote logic, another security risk. (Notably, as a subcase, objects may be pure records and those *are* shareable, since they are free from mutable state.)
-
-To compensate for this necessary limitation, `actor` objects *are shareable*, but always execute remotely. They communicate with shareable Motoko data only. Local objects interact in less restricted ways with themselves, and can pass any Motoko data to each other’s methods, including other objects. In most other ways, local objects (and classes) are non-shareable counterparts to actor objects (and classes).
-
-The [Mutable state](mutable-state.md) introduced declarations of private mutable state, in the form of `var`-bound variables and (mutable) array allocation. In this chapter, we use mutable state to implement simple objects, much like how we would implement simple objects in object-oriented programming.
-
-We illustrate this support via a running example, which continues in the next chapter. The following example illustrates a general evolution path for Motoko programs. Each *object*, if important enough, has the potential to be refactored into an Internet *service*, by refactoring this *(local) object* into an *actor object*.
-
-**Object classes**. Frequently, one needs *a family* of related objects to perform a task. When objects exhibit similar behavior, it makes sense to fabricate them according to the same blueprint, but with customizable initial state. To this end, Motoko provides a syntactical construct, called a `class` definition, which simplifies building objects of the same type and implementation. We introduce these after discussing objects.
-
-**Actor classes**. When an object class exposes a *[service](actors-async.md)* (asynchronous behavior), the corresponding Motoko construct is an [actor class](actors-async.md), which follows a similar (but distinct) design.
-
-## Example: The `counter` object
-
-Consider the following *object declaration* of the object value `counter`:
-
-``` motoko
-object counter {
-  var count = 0;
-  public func inc() { count += 1 };
-  public func read() : Nat { count };
-  public func bump() : Nat {
-    inc();
-    read()
-  };
-};
-```
-
-This declaration introduces a single object instance named `counter`, whose entire implementation is given above.
-
-In this example, the developer exposes three *public* functions `inc`, `read` and `bump` using keyword `public` to declare each in the object body. The body of the object, like a block expression, consists of a list of declarations.
-
-In addition to these three functions, the object has one (private) mutable variable `count`, which holds the current count, initially zero.
-
-## Object types
-
-This object `counter` has the following *object type*, written as a list of field-type pairs, enclosed in braces (`{` and `}`):
-
-``` motoko no-repl
-{
-  inc  : () -> () ;
-  read : () -> Nat ;
-  bump : () -> Nat ;
-}
-```
-
-Each field type consists of an identifier, a colon `:`, and a type for the field content. Here, each field is a function, and thus has an *arrow* type form (`_ → _`).
-
-In the declaration of `object`, the variable `count` was explicitly declared neither as `public` nor as `private`.
-
-By default, all declarations in an object block are `private`, as is `count` here. Consequently, the type for `count` does not appear in the type of the object, *and* its name and presence are both inaccessible from the outside.
-
-The inaccessibility of this field comes with a powerful benefit: By not exposing this implementation detail, the object has a *more general* type (fewer fields), and as a result, is interchangeable with objects that implement the same counter object type differently, without using such a field.
-
-## Example: The `byteCounter` object
-
-To illustrate the point just above, consider this variation of the `counter` declaration above, of `byteCounter`:
-
-``` motoko
-import Nat8 "mo:base/Nat8";
-object byteCounter {
-  var count : Nat8 = 0;
-  public func inc() { count += 1 };
-  public func read() : Nat { Nat8.toNat(count) };
-  public func bump() : Nat { inc(); read() };
-};
-```
-
-This object has the same type as the previous one, and thus from the standpoint of type checking, this object is interchangeable with the prior one:
-
-``` motoko no-repl
-{
-  inc  : () -> () ;
-  read : () -> Nat ;
-  bump : () -> Nat ;
-}
-```
-
-Unlike the first version, however, this version does not use the same implementation of the counter field. Rather than use an ordinary natural `Nat` that never overflows, but may also grow without bound, this version uses a byte-sized natural number (type `Nat8`) whose size is always eight bits.
-
-As such, the `inc` operation may fail with an overflow for this object, but never the prior one, which may instead (eventually) fill the program’s memory, a different kind of application failure.
-
-Neither implementation of a counter comes without some complexity, but in this case, they share a common type.
-
-In general, a common type shared among two implementations (of an object or service) affords the potential for the internal implementation complexity to be factored away from the rest of the application that uses it. Here, the common type abstracts over the simple choice of a number’s representation. In general, the implementation choices would each be more complex, and more interesting.
-
-## Object subtyping
-
-To illustrate the role and use of object subtyping in Motoko, consider implementing a simpler counter with a more general type (fewer public operations):
-
-``` motoko
-object bumpCounter {
-  var c = 0;
-  public func bump() : Nat {
-    c += 1;
-    c
-  };
-};
-```
-
-The object `bumpCounter` has the following object type, exposing exactly one operation, `bump`:
-
-``` motoko no-repl
-{
-  bump : () -> Nat ;
-}
-```
-
-This type exposes the most common operation, and one that only permits certain behavior. For instance, the counter can only ever increase, and can never decrease or be set to an arbitrary value.
-
-In other parts of a system, we may in fact implement and use a *less general* version, with *more* operations:
-
-``` motoko no-repl
-fullCounter : {
-  inc   : () -> () ;
-  read  : () -> Nat ;
-  bump  : () -> Nat ;
-  write : Nat -> () ;
-}
-```
-
-Here, we consider a counter named `fullCounter` with a less general type than any given above. In addition to `inc`, `read` and `bump`, it additionally includes `write`, which permits the caller to change the current count value to an arbitrary one, such as back to `0`.
-
-**Object subtyping.** In Motoko, objects have types that may relate by subtyping, as the various types of counters do above. As is standard, types with *more fields* are *less general* (are ***sub**types* of) types with *fewer fields*. For instance, we can summarize the types given in the examples above as being related in the following subtyping order:
-
--   Most general:
-
-``` motoko no-repl
-{ bump : () -> Nat }
-```
-
--   Middle generality:
-
-``` motoko no-repl
-{
-  inc  : () -> () ;
-  read : () -> Nat ;
-  bump : () -> Nat ;
-}
-```
-
--   Least generality:
-
-``` motoko no-repl
-{
-  inc  : () -> () ;
-  read : () -> Nat ;
-  bump : () -> Nat ;
-  write : Nat -> () ;
-}
-```
-
-If a function expects to receive an object of the first type (`{ bump: () → Nat }`), *any* of the types given above will suffice, since they are each equal to, or a subtype of, this (most general) type.
-
-However, if a function expects to receive an object of the last, least general type, the other two will *not* suffice, since they each lack the needed `write` operation, to which this function rightfully expects to have access.
-
-## Object classes
-
-In Motoko, an object encapsulates state, and an object `class` is a package of two entities that share a common name.
-
-Consider this example `class` for counters that start at zero:
-
-``` motoko name=counter
-class Counter() {
-  var c = 0;
-  public func inc() : Nat {
-    c += 1;
-    return c;
-  }
-};
-```
-
-The value of this definition is that we can *construct* new counters, each starting with their own unique state, initially at zero:
-
-``` motoko name=cinit include=counter
-let c1 = Counter();
-let c2 = Counter();
-```
-
-Each is independent:
-
-``` motoko include=counter,cinit
-let x = c1.inc();
-let y = c2.inc();
-(x, y)
-```
-
-We could achieve the same results by writing a function that returns an object:
-
-``` motoko
-func Counter() : { inc : () -> Nat } =
-  object {
-    var c = 0;
-    public func inc() : Nat { c += 1; c }
-  };
-```
-
-Notice the return type of this *constructor function* (an object type):
-
-``` motoko no-repl
-{ inc : () -> Nat }
-```
-
-We may want to name this type, for example, `Counter`, as follows, for use in further type declarations:
-
-``` motoko no-repl
-type Counter = { inc : () -> Nat };
-```
-
-In fact, the `class` keyword syntax shown above is nothing but a shorthand for these two definitions for `Counter`: a factory function `Counter` that constructs objects, and the type `Counter` of these objects. Classes do not provide any new functionality beyond this convenience.
-
-### Class constructor
-
-An object class defines a constructor function that may carry zero or more data arguments and zero or more type arguments.
-
-The `Counter` example above has zero of each.
-
-The type arguments, if any, parameterize both the type and the constructor function for the class.
-
-The data arguments, if any, parameterize (only) the constructor function for the class.
-
-#### Data arguments
-
-Suppose we want to initialize the counter with some non-zero value. We can supply that value as a data argument to the `class` constructor:
-
-``` motoko
-class Counter(init : Nat) {
-  var c = init;
-  public func inc() : Nat { c += 1; c };
-};
-```
-
-This parameter is available to all methods.
-
-For instance, we can `reset` the `Counter` to its initial value, a parameter:
-
-``` motoko
-class Counter(init : Nat) {
-  var c = init;
-  public func inc() : Nat { c += 1; c };
-  public func reset() { c := init };
-};
-```
-
-#### Type arguments
-
-Suppose we want the counter to actually carry data that it counts (like a specialized `Buffer`).
-
-When classes use or contain data of arbitrary type, they carry a type argument (or equivalently, *type parameter*) for that unknown type, just as with functions.
-
-The scope of this type parameter covers the entire `class`, just as with data parameters. As such, the methods of the class can use (and *need not re-introduce*) these type parameters.
-
-``` motoko
-import Buffer "mo:base/Buffer";
-
-class Counter(init : Buffer.Buffer) {
-  var buffer = init.clone();
-  public func add(x : X) : Nat {
-    buffer.add(x);
-    buffer.size()
-  };
-
-  public func reset() {
-    buffer := init.clone()
-  };
-};
-```
-
-#### Type annotation
-
-Optionally, the class constructor may also carry a type annotation for its "return type" (the type of objects that it produces). When supplied, Motoko checks that this type annotation is compatible with the body of the class (an object definition). This check ensures that each object produced by the constructor meets the supplied specification.
-
-For example, we repeat the `Counter` as a buffer, and annotate it with a more general type `Accum` that permits adding, but not resetting the counter. This annotation ensures that the objects are compatible with the type `Accum`.
-
-``` motoko
-import Buffer "mo:base/Buffer";
-
-type Accum = { add : X -> Nat };
-
-class Counter(init : Buffer.Buffer) : Accum {
-  var buffer = init.clone();
-  public func add(x : X) : Nat { buffer.add(x); buffer.size() };
-  public func reset() { buffer := init.clone() };
-};
-```
-
-#### Full syntax
-
-In full, classes are defined by the keyword `class`, followed by: - a name for the constructor and type being defined (for example, `Counter`) - optional type arguments (for example, omitted, or ``, or ``) - an argument list (for example, `()`, or `(init : Nat)`, etc.) - an optional type annotation for the constructed objects (for example, omitted, or `Accum`), - the class "body" is an object definition, parameterized by the type and value arguments (if any).
-
-The constituents of the body marked `public` contribute to the resulting objects' type and these types compared against the (optional) annotation, if given.
-
-##### Another example: `Bits`
-
-As another example, let’s consider the task of walking the bits of a natural number (type `Nat`). For this example, we could define the following:
-
-``` motoko
-class Bits(n : Nat) {
-  var state = n;
-  public func next() : ?Bool {
-    if (state == 0) { return null };
-    let prev = state;
-    state /= 2;
-    ?(state * 2 != prev)
-  }
-}
-```
-
-The above class definition is equivalent to the simultaneous definition of a structural type synonym and a factory function, both named `Bits`:
-
-``` motoko no-repl
-type Bits = {next : () -> ?Bool};
-func Bits(n : Nat) : Bits = object {
-  // class body
-};
-```
-
-## Structural subtyping
-
-Object subtyping in Motoko uses *structural subtyping*, not *nominal subtyping*.
-
-Recall that in nominal typing, the question of two types equality depends on choosing consistent, globally-unique type names (across projects and time).
-
-In Motoko, the question of two types' equality is based on their *structure*, not their names.
-
-Due to structural typing, naming the class type provides a convenient abbreviation.
-
-For typing purposes, however, all that matters is the *structure* of the corresponding object type: two classes with different names but equivalent definitions produce type-compatible objects.
-
-When the optional type annotation is supplied in a class declaration, conformance is checked: the object type must be a subtype of the annotation. The annotation does not affect the type of the class, however, even if it only describes a proper super-type of the object type.
-
-Formally, subtyping relationships in Motoko extend to all types, not just object types.
-
-Most cases are standard, and follow conventional programming language theory (for *structural* subtyping, specifically).
-
-Other notable cases in Motoko for new programmers include array, options, variants and number type inter-relationships.
diff --git a/doc/md/message-inspection.md b/doc/md/message-inspection.md
deleted file mode 100644
index 8e820d64834..00000000000
--- a/doc/md/message-inspection.md
+++ /dev/null
@@ -1,117 +0,0 @@
-# Message inspection
-
-On the Internet Computer, a canister can selectively *inspect* and *accept* or *decline* ingress messages submitted through the HTTP interface:
-
-> A canister can inspect ingress messages before executing them. When the IC receives an update call from a user, the IC will use the canister method `canister_inspect_message` to determine whether the message shall be accepted. If the canister is empty (i.e. does not have a Wasm module), then the ingress message will be rejected. If the canister is not empty and does not implement `canister_inspect_message`, then the ingress message will be accepted.
->
-> In `canister_inspect_message`, the canister can accept the message by invoking `ic0.accept_message : () → ()`. This function traps if invoked twice. If the canister traps in `canister_inspect_message` or does not call `ic0.accept_message`, then the access is denied.
->
-> The `canister_inspect_message` is *not* invoked for HTTP query calls, inter-canister calls or calls to the management canister.
->
-> —  [IC Interface Specification](https://smartcontracts.org/docs/current/references/ic-interface-spec/#ingress-message-inspection)
-
-Message inspection mitigates some denial of service attacks, designed to drain canisters of cycles by placing unsolicited free calls.
-
-:::note
-
-You can think of method inspection as providing the "Collect call from *name*. Do you accept charges?" prologue of an old-fashioned, operator-assisted, collect phone call.
-
-:::
-
-In Motoko, actors can elect to inspect and accept or decline ingress messages by declaring a particular `system` function called `inspect`. Given a record of message attributes, this function produces a `Bool` that indicates whether to accept or decline the message by returning `true` or `false`. The function is invoked (by the system) on each ingress message. Similar to a query, any side-effects of an invocation are discarded and transient. A call that traps due to some fault has the same result as returning `false` (message declination).
-
-Unlike other system functions, that have a fixed argument type, the argument type of `inspect` depends on the interface of the enclosing actor. In particular, the formal argument of `inspect` is a record of fields of the following types:
-
--   `caller : Principal`: the principal, possibly anonymous, of the caller of the message;
-
--   `arg : Blob`: the raw, binary content of the message argument;
-
--   `msg : `: a variant of *decoding* functions, where ` == {…​; #: () → T; …​}` contains one variant per shared function, ``, of the actor. The variant’s tag identifies the function to be called; The variant’s argument is a function that, when applied, returns the (decoded) argument of the call as a value of type `T`.
-
-Using a variant, tagged with `#`, allows the return type, `T`, of the decoding function to vary with the argument type (also `T`) of the shared function ``.
-
-The variant’s argument is a function so that one can avoid the expense of message decoding (when appropriate).
-
-Exploiting subtyping, the formal argument can omit record fields it does not require, or selectively ignore the arguments of particular shared functions, for example, in order to simply dispatch on the name of a function without inspecting its actual argument.
-
-:::note
-
-Confusingly, a `shared query` function *can* be called using a regular HTTP call to obtain a certified response: this is why the variant type also includes `shared query` functions.
-
-:::
-
-:::danger
-
-An actor that fails to declare system field `inspect` will simply accept all ingress messages.
-
-:::
-
-:::danger
-
-System function `inspect` should **not** be used for definitive access control. This is because `inspect` is executed by a single replica, without full consensus, and its result could be spoofed by a malicious boundary node. Reliable access control checks can only be performed within the `shared` functions guarded by `inspect`.
-
-:::
-
-## Example
-
-A simple, contrived example of method inspection is a counter actor, that inspects some of its messages in detail, and others only superficially:
-
-``` motoko file=./examples/InspectFull.mo
-```
-
-Note that, due to subtyping, all of the following variations, in order of increasing argument specificity, are legal definitions of `inspect`.
-
-Blanket denial of all ingress messages, ignoring further information:
-
-``` motoko no-repl file=./examples/InspectNone.mo#L10-L10
-```
-
-Declining anonymous calls:
-
-``` motoko no-repl file=./examples/InspectCaller.mo#L12-L14
-```
-
-Declining large messages, based on the raw size (in bytes) of `arg` (prior to any decoding from Candid binary blob to Motoko value):
-
-``` motoko no-repl file=./examples/InspectArg.mo#L12-L14
-```
-
-Declining messages by name only, ignoring message arguments (note the use of type `Any` as message argument variants):
-
-``` motoko no-repl file=./examples/InspectName.mo#L12-L25
-```
-
-A combination of the previous three, specifying the argument types of some variants while ignoring others at type `Any` and using pattern matching to conflate identical cases.
-
-``` motoko no-repl file=./examples/InspectMixed.mo#L12-L30
-```
-
-## Tips on authoring `inspect`
-
-Implementing `inspect` after the fact, once all shared functions of an actor have already been implemented, can be tedious, since you’ll need to declare a correctly typed variant for each shared function. A simple trick is to first implement the function *incorrectly*, with a `()` argument, compile the code, then use the compiler’s error message to obtain the required argument type.
-
-For example, in the actor from the previous section, incorrectly declaring:
-
-``` motoko no-repl file=./examples/InspectTrick.mo#L12-L14
-```
-
-forces the compiler to report the expected type below:
-
-``` motoko no-repl
-Inspect.mo:12.4-14.5: type error [M0127], system function inspect is declared with type
-  () -> Bool
-instead of expected type
-  {
-    arg : Blob;
-    caller : Principal;
-    msg :
-      {
-        #inc : () -> ();
-        #read : () -> ();
-        #reset : () -> ();
-        #set : () -> Nat
-      }
-  } -> Bool
-```
-
-which you can now cut-and-paste into your code.
diff --git a/doc/md/migration-guides/0.11.0-migration-guide.md b/doc/md/migration-guides/0.11.0-migration-guide.md
new file mode 100644
index 00000000000..e5c58de492a
--- /dev/null
+++ b/doc/md/migration-guides/0.11.0-migration-guide.md
@@ -0,0 +1,85 @@
+---
+sidebar_position: 2
+---
+
+
+# Motoko v0.11.0: Safety feature migration guide
+
+## Overview
+
+Motoko v0.11.0 and newer introduces a new safety feature that could cause breaking changes to existing code.
+
+In previous Motoko versions, third-party library functions could make calls to sensitive functions such as `ExperimentalCycles.add(...)` and `Timer.setTimer(...)` without providing any indication to the caller that sensitive system functionality was being used.
+
+In Motoko 0.11.0 and newer, the type system is used to detect and prevent this scenario while still allowing developers to grant access to sensitive functions.
+
+## Motoko v0.11.0 changes
+
+Motoko uses a simple capability-based type system which selectively enables language constructs depending on their context. One example is only `async` expressions can contain `await` expressions, or only some asynchronous contexts can call shared functions.
+
+In Motoko v0.11.0 and newer, this capability system is expanded to restrict calls to functions including `Timer.setTimer` and `ExperimentalCycles.add`. To accomplish this, Motoko introduces and uses the pseudo-type parameter `system` and corresponding pseudo-type argument (also `system`) for both functions and classes.
+
+Another change in v0.11.0 and newer is a revision of `ExperimentalCycles.add`, whose type has been changed from `Nat -> ()` to `Nat -> ()`. This change reflects the additional  `system` capability requirement using the type parameter ``.
+
+:::info
+The `system` type parameter must be the first parameter of any function, class constructor or function type, e.g. `` is valid but `` is not.
+:::
+
+## Migrations for existing workflows
+
+User-defined functions must now declare an explicit system pseudo-type parameter if they require system capabilities. If a caller wants to grant system capabilities to a callee, the caller must already have system capabilities either (implicitly) by virtue of the callsite's program context or (explicitly) because the callsite resides within a function or class that itself declares the new `system`  type parameter.
+
+For example, in previous Motoko versions the following could be used:
+
+```motoko no-repl
+  func splitCycles() {
+    let amount = ExperimentalCycles.balance() / 2;
+    ExperimentalCycles.add(amount); // new error
+  };
+```
+
+This code will now throw a compiler error such as:
+
+```
+`system` capability required, but not available
+(need an enclosing async expression or function body or explicit `system` type parameter)(M0197)
+```
+
+For Motoko v0.11.0 and newer, the previous code should be rewritten to include the system type parameter:
+
+```motoko no-repl
+ func splitCycles() {
+    let amount = ExperimentalCycles.balance() / 2;
+    ExperimentalCycles.add(amount); // warning
+  };
+```
+
+This code will include a warning to reflect that `ExperimentalCycles.add` is implicitly using system capability:
+
+```
+this function call implicitly requires `system` capability and may perform undesired actions (please review the call and provide a type instantiation `` to suppress this warning)(M0195)
+```
+
+This warning can be silenced by adding the pseudo-type argument `system` at the call-site:
+
+```motoko no-repl
+  func splitCycles() {
+    let amount = ExperimentalCycles.balance() / 2;
+    ExperimentalCycles.add(amount); // no warning or error
+  }
+```
+
+Developers whose code has proper capability related errors that prevent compilation will need to refactor their code to explicitly pass down the system capabilities using additional type parameters and arguments.
+
+## System capability syntax limitations
+
+System capability is available within the following contexts:
+
+- Within the body of an `actor` expression or `actor` class.
+- Within the body of a (non- `query`) `shared` function, asynchronous function, `async` expression or `async*` expression.
+- Within the body of a local (i.e. not `shared`) function or class that is declared with `system` pseudo-type parameter.
+- Within the system functions `preupgrade` and `postupgrade`.
+
+No other context provides system capabilities, including the bodies of query and composite query methods.
+
+Logo
diff --git a/doc/md/migration-guides/_category_.yml b/doc/md/migration-guides/_category_.yml
new file mode 100644
index 00000000000..fa3a13f790b
--- /dev/null
+++ b/doc/md/migration-guides/_category_.yml
@@ -0,0 +1,4 @@
+position: 7
+label: 'Migration guides'
+collapsible: true # make the category collapsible
+collapsed: true 
diff --git a/doc/md/migration-guides/overview.md b/doc/md/migration-guides/overview.md
new file mode 100644
index 00000000000..a11f4211582
--- /dev/null
+++ b/doc/md/migration-guides/overview.md
@@ -0,0 +1,13 @@
+---
+sidebar_position: 1
+---
+
+# Overview
+
+New versions of Motoko may introduce breaking changes that are not backwards compatible with older versions. In these scenarios, there are migration guides created to explain how to update your code to migrate to the new version properly. 
+
+## Migration guides
+
+- [0.11.0 Migration guide](0.11.0-migration-guide.md)
+
+Logo
diff --git a/doc/md/modules-and-imports.md b/doc/md/modules-and-imports.md
deleted file mode 100644
index 32043e5f788..00000000000
--- a/doc/md/modules-and-imports.md
+++ /dev/null
@@ -1,137 +0,0 @@
-# Modules and imports
-
-This section provides examples of different scenarios for using the `module` and `import` keywords.
-
-To illustrate how these keywords are used, let’s step through some sample code.
-
-## Importing from the Motoko base library
-
-One of the most common import scenarios is one that you see illustrated in the examples in this guide, in the Motoko projects in the examples repository, and in the tutorials involves importing modules from the Motoko base library. Importing modules from the base library enables you to re-use the values, functions and types defined in those modules rather than writing similar ones from scratch.
-
-The following two lines import functions from the `Array` and `Result` modules:
-
-``` motoko
-import Array "mo:base/Array";
-import Result "mo:base/Result";
-```
-
-Notice that the import declaration includes the `mo:` prefix to identify the module as a Motoko module and that the declaration does not include the `.mo` file type extension.
-
-Above example uses an identifier pattern to import modules wholesale, but you can also selectively import a subset of symbols from a module by resorting to the object pattern syntax:
-
-``` motoko
-import { map; find; foldLeft = fold } = "mo:base/Array";
-```
-
-In this example, the functions `map` and `find` are imported unaltered, while the `foldLeft` function is renamed to `fold`.
-
-## Importing local files
-
-Another common approach to writing programs in Motoko involves splitting up the source code into different modules. For example, you might design an application to use the following model:
-
--   a `main.mo` file to contain the actor and functions that change state.
-
--   a `types.mo` file for all of your custom type definitions.
-
--   a `utils.mo` file for functions that do work outside of the actor.
-
-In this scenario, you might place all three files in the same directory and use a local import to make the functions available where they are needed.
-
-For example, the `main.mo` contains the following lines to reference the modules in the same directory:
-
-``` motoko no-repl
-import Types "types";
-import Utils "utils";
-```
-
-Because these lines import modules from the local project instead of the Motoko library, these import declarations don’t use the `mo:` prefix.
-
-In this example, both the `types.mo` and `utils.mo` files are in the same directory as the `main.mo` file. Once again, import does not use the `.mo` file suffix.
-
-## Importing from another package or directory
-
-You can also import modules from other packages or from directories other than the local directory.
-
-For example, the following lines import modules from a `redraw` package that is defined as a dependency:
-
-``` motoko no-repl
-import Render "mo:redraw/Render";
-import Mono5x5 "mo:redraw/glyph/Mono5x5";
-```
-
-You can define dependencies for a project using the Vessel package manager or in the project `dfx.json` configuration file.
-
-In this example, the `Render` module is in the default location for source code in the `redraw` package and the `Mono5x5` module is in a `redraw` package subdirectory called `glyph`.
-
-## Importing actor classes
-
-While module imports are typically used to import libraries of local functions and values, they can also be used to import actor classes. When an imported file consists of a named actor class, the client of the imported field sees a module containing the actor class.
-
-This module has two components, both named after the actor class:
-
--   a type definition, describing the interface of the class, and
-
--   an asynchronous function, that takes the class parameters as arguments an asynchronously returns a fresh instance of the class.
-
-For example, a Motoko actor can import and instantiate the `Counter` class described in [Actors and async data](actors-async.md#actor-classes-generalize-actors) as follows:
-
-`Counters.mo`:
-
-``` motoko name=Counters file=./examples/Counters.mo
-```
-
-`CountToTen.mo`:
-
-``` motoko include=Counters file=./examples/CountToTen.mo
-```
-
-The call to `Counters.Counter(1)` installs a fresh counter on the network. Installation is asynchronous, so the caller must `await` the result.
-
-The type annotation `: Counters.Counter` is redundant here. It’s included only to illustrate that the type of the actor class is available when required.
-
-## Importing from another canister smart contract
-
-In addition to the examples above that import Motoko modules, you can also import actors (and their shared functions) from canister smart constracts by using the `canister:` prefix in place of the `mo:` prefix.
-
-:::note
-
-Unlike a Motoko library, an imported canister can be implemented in any other Internet Computer language that emits Candid interfaces for its canister smart contracts (for instance Rust). It could even be an older or newer version of Motoko.
-
-:::
-
-For example, you might have a project that produces the following three canisters:
-
--   BigMap (implemented in Rust)
-
--   Connectd (implemented in Motoko)
-
--   LinkedUp (implemented in Motoko)
-
-These three canisters are declared in the project’s `dfx.json` configuration file and compiled by running `dfx build`.
-
-You can then use the following lines to import the `BigMap` and `Connectd` canisters as actors in the Motoko LinkedUp actor:
-
-``` motoko no-repl
-import BigMap "canister:BigMap";
-import Connectd "canister:connectd";
-```
-
-When importing canisters, it is important to note that the type for the imported canister corresponds to a **Motoko actor** instead of a **Motoko module**. This distinction can affect how some data structures are typed.
-
-For the imported canister actor, types are derived from the Candid file — the *project-name*.did file — for the canister rather than from Motoko itself.
-
-The translation from Motoko actor type to Candid service type is mostly, but not entirely, one-to-one, and there are some distinct Motoko types that map to the same Candid type. For example, the Motoko `Nat32` and `Char` types both exported as Candid type `nat32`, but `nat32` is canonically imported as Motoko `Nat32`, not `Char`.
-
-The type of an imported canister function, therefore, might differ from the type of the original Motoko code that implements it. For example, if the Motoko function had type `shared Nat32 -> async Char` in the implementation, its exported Candid type would be `(nat32) -> (nat32)` but the Motoko type imported from this Candid type will actually be the correct—but perhaps unexpected—type `shared Nat32 -> async Nat32`.
-
-## Naming imported modules
-
-Although the most common convention is to identify imported modules by the module name as illustrated in the examples above, there’s no requirement for you to do so. For example, you might want to use different names to avoid naming conflicts or to simplify the naming scheme.
-
-The following examples illustrate different names you might use when importing the `List` base library module, avoiding a clash with another `List` library from a fictional `collections` package.
-
-``` motoko no-repl
-import List "mo:base/List:";
-import Sequence "mo:collections/List";
-import L "mo:base/List";
-```
diff --git a/doc/md/motoko-grammar.md b/doc/md/motoko-grammar.md
deleted file mode 100644
index 3214b8dd53a..00000000000
--- a/doc/md/motoko-grammar.md
+++ /dev/null
@@ -1,6 +0,0 @@
-# Motoko grammar
-
-This section describes the concrete syntax, or grammar, of Motoko. The specification is auto-generated with a tool.
-
-``` bnf file=./examples/grammar.txt
-```
diff --git a/doc/md/motoko-introduction.md b/doc/md/motoko-introduction.md
deleted file mode 100644
index 72b79925fed..00000000000
--- a/doc/md/motoko-introduction.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# Introduction
-
-Motoko is a modern, general-purpose programming language you can use specifically to author [Internet Computer](../../concepts/what-is-IC.md) canister smart contracts. Although aimed squarely at the Internet Computer, its design is general enough to support future compilation to other targets.
-
-## Approachability
-
-Motoko is a modern language designed to be approachable for programmers who have some basic familiarity with modern object-oriented and/or functional programming idioms in either JavaScript, or another modern programming language, such as Rust, Swift, TypeScript, C#, or Java.
-
-## Asynchronous messaging and type sound execution
-
-Motoko permits modern programming idioms, including special programming abstractions for distributed applications (dapps). Each dapp consists of one or more *actors* that communicate solely by *asynchronous message passing*. The state of an actor is isolated from all other actors, supporting distribution. There is no way to share state between several actors. The actor-based programming abstractions of Motoko permit human-readable message-passing patterns, and they enforce that each network interaction obeys certain rules and avoids certain common mistakes.
-
-Specifically, Motoko programs are *type sound* since Motoko includes a practical, modern type system that checks each one before it executes. The Motoko type system statically checks that each Motoko program will execute safely, without dynamic type errors, on all possible inputs. Consequently, entire classes of common programming pitfalls that are common in other languages, and web programming languages in particular, are ruled out. This includes null reference errors, mis-matched argument or result types, missing field errors and many others.
-
-To execute, Motoko statically compiles to [WebAssembly](about-this-guide.md#webassembly), a portable binary format that abstracts cleanly over modern computer hardware, and thus permits its execution broadly on the Internet, and the [Internet Computer](../../concepts/what-is-IC.md).
-
-## Each canister smart contract as an *actor*
-
-Motoko provides an **actor-based** programming model to developers to express *services*, including those of canister smart contracts on the [Internet Computer](../../concepts/what-is-IC.md).
-
-An actor is similar to an object, but is special in that its state is completely isolated, and all its interactions with the world are by *asynchronous* messaging.
-
-All communication with and between actors involves passing messages asynchronously over the network using the Internet Computer’s messaging protocol. An actor’s messages are processed in sequence, so state modifications never admit race conditions (unless explicitly allowed by punctuating `await` expressions).
-
-The Internet Computer ensures that each message that is sent receives a response. The response is either success with some value, or an error. An error can be the explicit rejection of the message by the receiving canister, a trap due to an illegal instruction such as division by zero, or a system error due to distribution or resource constraints. For example, a system error might be the transient or permanent unavailability of the receiver (either because the receiving actor is oversubscribed or has been deleted).
-
-### Asynchronous actors
-
-Like other *modern* programming languages, Motoko permits an ergonomic syntax for *asynchronous* communication among components.
-
-In the case of Motoko, each communicating component is an actor.
-
-As an example of *using* actors, perhaps as an actor ourselves, consider this three-line program:
-
-``` motoko no-repl
-let result1 = service1.computeAnswer(params);
-let result2 = service2.computeAnswer(params);
-finalStep(await result1, await result2)
-```
-
-We can summarize the program’s behavior with three steps:
-
-1.  The program makes two requests (lines 1 and 2) to two distinct services, each implemented as a Motoko actor or canister smart contract implemented in some other language.
-
-2.  The program waits for each result to be ready (line 3) using the keyword `await` on each result value.
-
-3.  The program uses both results in the final step (line 3) by calling the `finalStep` function.
-
-Generally-speaking, the services *interleave* their executions rather than wait for one another, since doing so reduces overall latency. However, if we try to reduce latency this way *without* special language support, such interleaving will quickly sacrifice clarity and simplicity.
-
-Even in cases where there are *no* interleaving executions (for example, if there were only one call above, not two), the programming abstractions still permit clarity and simplicity, for the same reason. Namely, they signal to the compiler where to transform the program, freeing the programmer from contorting the program’s logic in order to interleave its execution with the underlying system’s message-passing loop.
-
-Here, the program uses `await` in line 3 to express that interleaving behavior in a simple fashion, with human-readable syntax that is provided by Motoko.
-
-In language settings that lack these abstractions, developers would not merely call these two functions directly, but would instead employ very advanced programming patterns, possibly registering developer-provided “callback functions” within system-provided “event handlers”. Each callback would handle an asynchronous event that arises when an answer is ready. This kind of systems-level programming is powerful, but very error-prone, since it decomposes a high-level data flow into low-level system events that communicate through shared state. Sometimes this style is necessary, but here it is not.
-
-Our program instead eschews that more cumbersome programming style for this more natural, *direct* style, where each request resembles an ordinary function call. This simpler, stylized programming form has become increasingly popular for expressing practical systems that interact with an *external environment*, as most modern software does today. However, it requires special compiler and type-system support, as we discuss in more detail below.
-
-### Support for *asynchronous* behavior
-
-In an *asynchronous* computing setting, a program and its running environment are permitted to perform *internal computations* that occur *concurrently* with one another.
-
-Specifically, asynchronous programs are ones where the program’s requests of its environment do not (necessarily) require the program to wait for the environment. In the meantime, the program is permitted to make internal progress within this environment while the environment proceeds to complete the request. In the example, above, the program issues the second request before waiting for the first request to complete.
-
-Symmetrically, the environment’s requests of the program do not (necessarily) require the environment to wait for the program’s answer: the environment can make external progress while the answer is produced.
-
-We do not show an example of this “notify” pattern above, since it uses callbacks (and *higher-order* functions and control flow) and is thus more complex.
-
-### Syntactic forms `async` and `await`
-
-To address the need for clarity and simplicity, Motoko adopts the increasingly-common program constructs `async` and `await`, which afford the programmer a *structured* language for describing potentially-complex asynchronous dependency graphs.
-
-The [async](language-manual.md#async) syntax introduces futures. A future value represents a *promise* of a result *that will be delivered, asynchronously, sometime in the future* (not shown in the first example above). You’ll learn more about futures when we introduce actors in [Actors and async data](actors-async.md).
-
-Here, we merely use the ones that arise from calling `service1.computeAnswer(params)` and `service2.computeAnswer(params)`.
-
-The syntax `await` synchronizes on a future, and suspends computation until the future is completed by its producer. We see two uses of `await` in the example above, to obtain the results from two calls to services.
-
-When the developer uses these keywords, the compiler transforms the program as necessary, often doing complex transformations to the program’s control- and data-flow that would be tedious to perform by hand in a purely synchronous language. Meanwhile, the type system of Motoko enforces certain correct usage patterns for these constructs, including that types flowing between consumers and producers always agree, and that the types of data sent among services are permitted to flow there, and do not (for example) contain [private mutable state](mutable-state.md).
-
-### Types are static
-
-Like other modern programming languages, Motoko permits each variable to carry the value of a function, object, or a primitive datum (for example, a string, word, or integer). Other [types of values](basic-concepts.md#intro-values) exist too, including records, tuples, and “tagged data” called *variants*.
-
-Motoko enjoys the formal property of type safety, also known as *type soundness*. We often summarize this idea with the phrase: [Well-typed Motoko programs don’t go wrong](basic-concepts.md#type-soundness), meaning that the only operations that will be performed on data are those permitted by its static type.
-
-For example, each variable in a Motoko program carries an associated *type*, and this type is known *statically*, before the program executes. Each use of each variable is checked by the compiler to prevent runtime type errors, including null reference errors, invalid field access and the like.
-
-In this sense, Motoko types provide a form of *trustworthy, **compiler-verified** documentation* in the program source code.
-
-As usual, dynamic testing can check properties that are beyond the reach of the Motoko type system. While modern, the Motoko type system is intentionally *not* “advanced” or particularly exotic. Rather, the type system of Motoko integrates standard concepts from modern, but well-understood, [modern type systems](about-this-guide.md#modern-type-systems) to provide an approachable, expressive yet safe language for programming general-purpose, distributed applications.
diff --git a/doc/md/motoko-packages/_category_.yml b/doc/md/motoko-packages/_category_.yml
new file mode 100644
index 00000000000..4ce59a760e0
--- /dev/null
+++ b/doc/md/motoko-packages/_category_.yml
@@ -0,0 +1,4 @@
+position: 6
+label: 'Motoko packages'
+collapsible: true # make the category collapsible
+collapsed: true
\ No newline at end of file
diff --git a/doc/md/motoko-packages/cryptography.md b/doc/md/motoko-packages/cryptography.md
new file mode 100644
index 00000000000..147b873e3d9
--- /dev/null
+++ b/doc/md/motoko-packages/cryptography.md
@@ -0,0 +1,27 @@
+---
+sidebar_position: 1
+---
+
+# Cryptography
+
+## Mops packages for cryptography
+
+[Mops](https://mops.one/) is an onchain package manager for Motoko. Here are some Mops packages for cryptography functions:
+
+- [`ic-certification`](https://mops.one/ic-certification): Canister signatures and certifications.
+
+- [`ed25519`](https://mops.one/ed25519): Ed25519 signatures.
+
+- [`evm-proof-verifier`](https://mops.one/evm-proof-verifier): EVM proof verification.
+
+- [`evm-txs`](https://mops.one/evm-txs): EVM transaction creating, encoding, and decoding for Motoko implementations.
+
+- [`libsecp256k1`](https://mops.one/libsecp256k1): A Motoko implementation of libsecp256k1.
+
+- [`merkle-patricia-trie`](https://mops.one/merkle-patricia-trie): A Merkle Patricia Trie implementation following the Ethereum specification.
+
+- [`sha2`](https://mops.one/sha2): An optimized implementation of all SHA2 functions.
+
+- [`sha3`](https://mops.one/sha3): A Motoko SHA3/Keccak library.
+
+Logo
diff --git a/doc/md/motoko-packages/data-structures.md b/doc/md/motoko-packages/data-structures.md
new file mode 100644
index 00000000000..3084a281cb8
--- /dev/null
+++ b/doc/md/motoko-packages/data-structures.md
@@ -0,0 +1,52 @@
+---
+sidebar_position: 2
+---
+
+# Data structures
+
+## Mops packages for data structures
+
+[Mops](https://mops.one/) is an onchain package manager for Motoko. Here are some Mops packages for data structure implementations:
+
+- [`augmented-btrees`](https://mops.one/augmented-btrees): An implementation of BTree variants, most notable the B+Tree.
+
+- [`buffer-deque`](https://mops.one/buffer-deque): A Buffer with Deque functionality of a Deque for efficient insertion and deletion at both ends.
+
+- [`bitbuffer`](https://mops.one/bitbuffer): Bit level and byte level manipulation.
+
+- [`circular-buffer`](https://mops.one/circular-buffer): Circular buffer implementation.
+
+- [`enumeration`](https://mops.one/enumeration): Add-only key sets with numbering and two-way lookup.
+
+- [`linked-list`](https://mops.one/linked-list): Doubly linked lists, featuring functions for node-level access.
+
+- [`map`](https://mops.one/map): Stable hash maps.
+
+- [`memory-buffer`](https://mops.one/memory-buffer): Persistent buffer implementations.
+
+- [`memory-hashlist`](https://mops.one/memory-hashlist): Storing and accessing blobs into memory associated with blob-key.
+
+- [`memory-hashtable`](https://mops.one/memory-hashtable): Storing, updating, deleting, and retrieving a single blob-value per key.
+
+- [`merkle-patricia-trie`](https://mops.one/merkle-patricia-trie): A Merkle Patricia Trie implementation following the Ethereum specification
+
+- [`splay`](https://mops.one/splay): A library for splay trees.
+
+- [`stable-buffer`](https://mops.one/stable-buffer): Buffers implemented in stable regions.
+
+- [`stable-enum`](https://mops.one/stable-enum): Enumerations implemented in stable regions.
+
+- [`stableheapbtreemap`](https://mops.one/stableheapbtreemap): BTreeMaps that can persist across upgrades via a stable variable in heap memory.
+
+- [`stable-rbtree`](https://mops.one/stable-rbtree): Stable RBtree.
+
+- [`stable-trie`](https://mops.one/stable-trie): Stable trie.
+
+- [`swb`](https://mops.one/swb): Sliding window buffers featuring random access functionalities.
+
+- [`swbstable`](https://mops.one/swbstable): Stable sliding window buffer with random access.
+
+- [`vector`](https://mops.one/vector): Memory-efficient resizable array. Can be used as a replacement for `Buffer`.
+
+
+Logo
diff --git a/doc/md/motoko-packages/databases.md b/doc/md/motoko-packages/databases.md
new file mode 100644
index 00000000000..6dddd64c176
--- /dev/null
+++ b/doc/md/motoko-packages/databases.md
@@ -0,0 +1,23 @@
+---
+sidebar_position: 3
+---
+
+# Databases
+
+## Mops packages for databases
+
+[Mops](https://mops.one/) is an onchain package manager for Motoko. Here are some Mops packages for database implementations:
+
+- [`candb`](https://mops.one/candb): A flexible, performant, and scalable non-relational, multi-canister data store built for ICP.
+
+- [`candb-multi`](https://mops.one/candb-multi): An add on to CanDB that allows you to work with multiple partition canisters at once.
+
+- [`new-candb`](https://mops.one/new-candb): A new form of CanDB that features an autoscaling option.
+
+- [`nacdb`](https://mops.one/nacdb): Multi-canister databases with seamless enumeration.
+
+- [`nacdb-reorder`](https://mops.one/nacdb-reorder): Re-orderable lists in NacDB database.
+
+- [`rxmodb`](https://mops.one/rxmodb): Motoko databases using `Vector` for main storage and `BTree` for indexes.
+
+Logo
diff --git a/doc/md/motoko-packages/encoding.md b/doc/md/motoko-packages/encoding.md
new file mode 100644
index 00000000000..c46dc2fd030
--- /dev/null
+++ b/doc/md/motoko-packages/encoding.md
@@ -0,0 +1,27 @@
+---
+sidebar_position: 4
+---
+
+# Encoding
+
+## Mops packages for encoding
+
+[Mops](https://mops.one/) is an onchain package manager for Motoko. Here are some Mops packages for encoding:
+
+- [`candid`](https://mops.one/candid): Encoding and decode Candid bytes.
+
+- [`candy`](https://mops.one/candy): Used for type conversions and creating workable collections.
+
+- [`candy-utils`](https://mops.one/candy-utils): Candy path and schema functionality built for the candy library.
+
+- [`cbor`](https://mops.one/cbor): Encoding and decode CBOR bytes.
+
+- [`deflate`](https://mops.one/deflate): Deflate compression and decompression algorithms with support for .gzip files.
+
+- [`rep-indy-hash`](https://mops.one/rep-indy-hash): Representational independent hashes.
+
+- [`serde`](https://mops.one/serde): Serialization and deserialization.
+
+- [`xml`](https://mops.one/xml): Encode and decode XML.
+
+Logo
diff --git a/doc/md/motoko-packages/http.md b/doc/md/motoko-packages/http.md
new file mode 100644
index 00000000000..4c3551b86a7
--- /dev/null
+++ b/doc/md/motoko-packages/http.md
@@ -0,0 +1,43 @@
+---
+sidebar_position: 5
+---
+
+# HTTP
+
+## Mops packages for HTTP
+
+[Mops](https://mops.one/) is an onchain package manager for Motoko. Here are some Mops packages for HTTP and web functionalities:
+
+- [`assets`](https://mops.one/assets): A library for adding asset canister functionality for your canister.
+
+- [`assets-api`](https://mops.one/assets-api): API package for asset canisters.
+
+- [`certified-assets`](https://mops.one/certified-assets): Certify assets served via HTTP, ensuring the security of query calls on ICP.
+
+- [`certified-cache`](https://mops.one/certified-cache): A single interface that stores key-value pairs and certifies their hashes for to be used as certified variables or assets.
+
+- [`certified-http`](https://mops.one/certified-http): Similar to `certified-cache`, an interface that stores key-value pairs and certifies their hashes for use as certified assets or variables.
+
+- [`http-loopback`](https://mops.one/http-loopback): Call canisters using HTTP outcalls.
+
+- [`http-parser`](https://mops.one/http-parser): HTTP request parser for parsing URLs, search queries, headers and form data.
+
+- [`http-types`](https://mops.one/http-types): Canister HTTP interface types used in `http_request` and `http_request_update`.
+
+- [`ic-assets`](https://mops.one/ic-assets): Asset canister with v2 certification.
+
+- [`ic-certification`](https://mops.one/ic-certification): Canister signatures and certification.
+
+- [`ic-websocket-cdk`](https://mops.one/ic-websocket-cdk): Websockets on ICP.
+
+- [`idempotency-keys`](https://mops.one/idempotency-keys): Package for generating UUIDs.
+
+- [`motoko-certified-assets`](https://mops.one/motoko-certified-assets): ICP certified assets.
+
+- [`promtracker`](https://mops.one/promtracker): Prometheus value tracking.
+
+- [`server`](https://mops.one/server): A server for Motoko similar to Express.
+
+- [`web-api`](https://mops.one/web-api) and [`web-io`](https://mops.one/web-io): Create HTTP requests and handle responses.
+
+Logo
diff --git a/doc/md/motoko-packages/icrc.md b/doc/md/motoko-packages/icrc.md
new file mode 100644
index 00000000000..dca3dafd3d5
--- /dev/null
+++ b/doc/md/motoko-packages/icrc.md
@@ -0,0 +1,55 @@
+---
+sidebar_position: 5
+---
+
+# ICRC
+
+## Mops packages for ICRC
+
+[Mops](https://mops.one/) is an onchain package manager for Motoko. Here are some Mops packages for ICRC tokens:
+
+- [`account`](https://mops.one/account): Implementation of ICRC-1 and ICRC-7 accounts.
+
+- [`account-identifier`](https://mops.one/account-identifier): Account identifiers for the ICP ledger.
+
+- [`auction`](https://mops.one/auction): Package for auction functionality.
+
+- [`devefi-icrc-ledger`](https://mops.one/devefi-icrc-ledger): Local ICRC ledger syncing with remote ledger.
+
+- [`devefi-icrc-reader`](https://mops.one/devefi-icrc-reader): Read the ICRC ledger transaction log.
+
+- [`devefi-icrc-sender`](https://mops.one/devefi-icrc-sender): Send ledger transactions.
+
+- [`icrc1`](https://mops.one/icrc1) and [`icrc1-mo`](https://mops.one/icrc1-mo): ICRC-1 libraries.
+
+- [`icrc1-types`](https://mops.one/icrc1-types): ICRC-1 canister interface types.
+
+- [`icrc2-mo`](https://mops.one/icrc2-mo): ICRC-2 library.
+
+- [`icrc2-types`](https://mops.one/icrc2-types): ICRC-2 canister interface types, including support for ICRC-1.
+
+- [`icrc2-batch`](https://mops.one/icrc2-batch): ICRC-2 batch transactions.
+
+- [`icrc3-mo`](https://mops.one/icrc3-mo): ICRC-3 library.
+
+- [`icrc30-mo`](https://mops.one/icrc30-mo): ICRC-30 library.
+
+- [`icrc4-mo`](https://mops.one/icrc4-mo): ICRC-4 library.
+
+- [`icrc45-mo`](https://mops.one/icrc45): ICRC-45 library.
+
+- [`icrc7-mo`](https://mops.one/icrc7-mo): ICRC-7 library.
+
+- [`icrc75-mo`](https://mops.one/icrc75-mo): ICRC-75 library.
+
+- [`icrc-fungible`](https://mops.one/icrc-fungible): Support for fungible tokens ICRC-1, ICRC-2, ICRC-3, ICRC-4, and ICRC-10.
+
+- [`icrc-nft-mo`](https://mops.one/icrc-nft-mo): An ICRC NFT library.
+
+- [`origyn-nft`](https://mops.one/origyn-nft): The reference implementation for the ORIGYN NFT.
+
+- [`ovs-fixed`](https://mops.one/ovs-fixed): ICRC-85 fixed open value sharing.
+
+- [`ovs-ledger`](https://mops.one/ovs-ledger): Open value sharing ledger.
+
+Logo
diff --git a/doc/md/motoko-packages/types-interfaces.md b/doc/md/motoko-packages/types-interfaces.md
new file mode 100644
index 00000000000..4aa7c123868
--- /dev/null
+++ b/doc/md/motoko-packages/types-interfaces.md
@@ -0,0 +1,40 @@
+---
+sidebar_position: 6
+---
+
+# Types and interfaces
+
+## Mops packages for types and interfaces
+
+[Mops](https://mops.one/) is an onchain package manager for Motoko. Here are some Mops packages for types and interfaces:
+
+- [`canistergeek`](https://mops.one/canistergeek): An open-source tool for tracking your project's cycles, memory status and logs.
+
+- [`ckbtc-types`](https://mops.one/ckbtc-types): Types and interfaces for interacting with ckBTC minter, ledger, index, and archive canisters.
+
+- [`devefi-icrc-ledger`](https://mops.one/devefi-icrc-ledger): Local ICRC ledger syncing with remote ledger.
+
+- [`devefi-icrc-reader`](https://mops.one/devefi-icrc-reader): Read the ICRC ledger transaction log.
+
+- [`devefi-icrc-sender`](https://mops.one/devefi-icrc-sender): Send ledger transactions.
+
+- [`http-types`](https://mops.one/http-types): Canister HTTP interface types used in `http_request` and `http_request_update`.
+
+- [`ic`](https://mops.one/ic): The ICP management canister interface.
+
+- [`icrc1-types`](https://mops.one/icrc1-types): ICRC-1 canister interface types.
+
+- [`icrc2-types`](https://mops.one/icrc2-types): ICRC-2 canister interface types, including support for ICRC-1.
+
+- [`ledger-types`](https://mops.one/ledger-types): ICP ledger canister types.
+
+- [`kyc`](https://mops.one/kyc): A client for interacting with ICRC-17 KYC servers.
+
+- [`promtracker`](https://mops.one/promtracker): Prometheus value tracking.
+
+- [`xrc-types`](https://mops.one/xrc-types): Exchange rate canister interface.
+
+
+Logo
+
+
diff --git a/doc/md/motoko-packages/utilities.md b/doc/md/motoko-packages/utilities.md
new file mode 100644
index 00000000000..417c01bc8a0
--- /dev/null
+++ b/doc/md/motoko-packages/utilities.md
@@ -0,0 +1,70 @@
+---
+sidebar_position: 7
+---
+
+# Utilities
+
+## Mops packages for utility functions
+
+[Mops](https://mops.one/) is an onchain package manager for Motoko. Here are some Mops packages for utility functions:
+
+- [`backup`](https://mops.one/backup): Library for backup restore.
+
+- [`bench`](https://mops.one/bench): Benchmarking library.
+
+- [`cycles-simple`](https://mops.one/cycles-simple): Manage the cycles balance of child canisters.
+
+- [`dao-proposal-engine`](https://mops.one/dao-proposal-engine): DAO proposal module.
+
+- [`datetime`](https://mops.one/datetime): `DateTime` values and manipulation.
+
+- [`ekvm`](https://mops.one/ekvm): Infinitely scalable elastic key-value store.
+
+- [`fuzz`](https://mops.one/fuzz): Random data generation.
+
+- [`itertools`](https://mops.one/itertools): Utility functions and data types for creating efficient iterators.
+
+- [`lru-cache`](https://mops.one/lru-cache): Least recently used cache implementation.
+
+- [`json.mo`](https://mops.one/json.mo): A library for JSON formatting.
+
+- [`math`](https://mops.one/math): Linear algebra and mathematical calculus library.
+
+- [`make-rules`](https://mops.one/make-rules): Library for using GNU make.
+
+- [`motoko-crc`](https://mops.one/motoko-crc): Cyclic redundancy checks for Motoko.
+
+- [`neuro`](https://mops.one/neuro): Basic staking and neuron management.
+
+- [`passport-client`](https://mops.one/passport-client): Use Gitcoin Passport anti-Sybil information.
+
+- [`principal-ext`](https://mops.one/principal-ext): Principal utility module.
+
+- [`prng`](https://mops.one/prng): Statistical pseudo-random number generators.
+
+- [`random`](https://mops.one/random): Generate random data.
+
+- [`random-class`](https://mops.one/random-class): Random number generator objects.
+
+- [`tecdsa`](https://mops.one/tecdsa): Generate and manage tECDSA identities.
+
+- [`test`](https://mops.one/test): Motoko testing library.
+
+- [`time`](https://mops.one/time): Timestamps in nano, micro, millis, and seconds to string `date` or `DateType`.
+
+- [`timer-tool`](https://mops.one/timer-tool): Module for creating timers.
+
+- [`time-consts`](https://mops.one/time-consts): Time constants for Motoko.
+
+- [`utilities`](https://mops.one/utilities): Class objects.
+
+- [`uuid`](https://mops.one/uuid): Universally unique identifier library.
+
+- [`xtended-numbers`](https://mops.one/xtended-numbers): Extended functionality for number types, such as byte encoding.
+
+- [`xtended-random`](https://mops.one/xtended-random): Extended library for random number generation.
+
+- [`xtended-text`](https://mops.one/xtended-text): Text manipulation.
+
+
+Logo
diff --git a/doc/md/motoko-tools/_attachments/embed-motoko-1.png b/doc/md/motoko-tools/_attachments/embed-motoko-1.png
new file mode 100644
index 00000000000..8a1fe0a2652
Binary files /dev/null and b/doc/md/motoko-tools/_attachments/embed-motoko-1.png differ
diff --git a/doc/md/motoko-tools/_attachments/embed-motoko-2.png b/doc/md/motoko-tools/_attachments/embed-motoko-2.png
new file mode 100644
index 00000000000..0f571465e9e
Binary files /dev/null and b/doc/md/motoko-tools/_attachments/embed-motoko-2.png differ
diff --git a/doc/md/motoko-tools/_attachments/embed-motoko-3.png b/doc/md/motoko-tools/_attachments/embed-motoko-3.png
new file mode 100644
index 00000000000..a0c1fef74de
Binary files /dev/null and b/doc/md/motoko-tools/_attachments/embed-motoko-3.png differ
diff --git a/doc/md/motoko-tools/_category_.yml b/doc/md/motoko-tools/_category_.yml
new file mode 100644
index 00000000000..288d1e64822
--- /dev/null
+++ b/doc/md/motoko-tools/_category_.yml
@@ -0,0 +1,4 @@
+position: 5
+label: 'Motoko tools'
+collapsible: true # make the category collapsible
+collapsed: true 
diff --git a/doc/md/motoko-tools/embed-motoko.md b/doc/md/motoko-tools/embed-motoko.md
new file mode 100644
index 00000000000..872886fdb3a
--- /dev/null
+++ b/doc/md/motoko-tools/embed-motoko.md
@@ -0,0 +1,45 @@
+---
+sidebar_position: 1
+---
+
+# Embed Motoko
+
+## Overview
+
+The Embed Motoko tool enables Motoko smart contracts to be embedded in web pages such as a blog, web application, or even a Medium article. Simply insert your Motoko smart contract into the Embed Motoko tool and copy either the generated embedded URL or the HTML iframe to use in your web page.
+
+## Simple example
+
+Navigate to the [Embed Motoko web-based tool](https://embed.smartcontracts.org/).
+
+Insert your Motoko code into the web-based code editor. This example uses a simple 'Hello world!' example.
+
+![Embedded Motoko 1](./_attachments/embed-motoko-1.png)
+
+To get the embedded URL for this smart contract, click on the link icon in the top right corner:
+
+![Embedded Motoko 2](./_attachments/embed-motoko-2.png)
+
+The console output on the page will confirm that the embedded URL has been copied to your clipboard. The embedded URL will resemble the following:
+
+```
+https://embed.smartcontracts.org/motoko/g/RnWsYTzKuWEyzDDgFaFBJvYjkiAvqAQvqFBrkv4HLUUBkAQQSTWHz8NneJy4cRbJgS6NToPXdZxYo1YDGry7NDR9kYcFspuLMSNkXggQZMyB17YhUkMvYNp4HSF3Hoxewg4C8skNyaNhVhtifvKm3WypBcogAXJEccqQEAVz?lines=10
+```
+
+You can also get the HTML iframe code by clicking on the `` icon in the top right corner:
+
+![Embedded Motoko 1](./_attachments/embed-motoko-1.png)
+
+The console output on the page will confirm that the iframe code has been copied. The iframe will resemble the following:
+
+```
+