diff --git a/.eslintignore b/.eslintignore index 882f7100d..ebdeff259 100644 --- a/.eslintignore +++ b/.eslintignore @@ -7,4 +7,5 @@ src/func/funcfiftlib.js src/grammar/grammar.ohm*.ts src/grammar/grammar.ohm*.js jest.setup.js -jest.teardown.js \ No newline at end of file +jest.teardown.js +/docs diff --git a/.github/PULL_REQUEST_TEMPLATE/code-quality.md b/.github/PULL_REQUEST_TEMPLATE/code-quality.md index ab9d629f8..8764c0212 100644 --- a/.github/PULL_REQUEST_TEMPLATE/code-quality.md +++ b/.github/PULL_REQUEST_TEMPLATE/code-quality.md @@ -3,7 +3,7 @@ IMPORTANT: If your PR doesn't close a particular issue, please, create the issue first and describe the whole context: what you're adding/changing and why you're doing so. And only then open the Pull Request, which would close that issue! IMPORTANT: -In general, the Tact team does not accept refactorings from external contributors unless those were previously discussed and you the green light to do change things without adding new functionality or fixing something broken. Language features, bugfixes, doc improvements are more than welcome! +In general, the Tact team does not accept refactorings from external contributors unless those were previously discussed and you've got the green light to change things without adding new functionality or to fix something broken. Language features, bugfixes, doc improvements are more than welcome! --> ## Issue diff --git a/.github/PULL_REQUEST_TEMPLATE/language-feature.md b/.github/PULL_REQUEST_TEMPLATE/language-feature.md index b092e6086..94955619f 100644 --- a/.github/PULL_REQUEST_TEMPLATE/language-feature.md +++ b/.github/PULL_REQUEST_TEMPLATE/language-feature.md @@ -10,7 +10,7 @@ Closes #number. ## Checklist - [ ] I have updated CHANGELOG.md -- [ ] I have documented my contribution in Tact Docs: https://github.com/tact-lang/tact-docs/pull/PR-NUMBER +- [ ] I have documented my contribution in `docs/` and made the build locally - [ ] I have added tests to demonstrate the contribution is correctly implemented: this usually includes both positive and negative tests, showing the happy path(s) and featuring intentionally broken cases - [ ] I have run all the tests locally and no test failure was reported - [ ] I have run the linter, formatter and spellchecker diff --git a/.github/workflows/tact-docs-prod.yml b/.github/workflows/tact-docs-prod.yml new file mode 100644 index 000000000..e039fb7d5 --- /dev/null +++ b/.github/workflows/tact-docs-prod.yml @@ -0,0 +1,52 @@ +# Deploy to GitHub Pages (production) +name: Build and deploy docs/ to GitHub Pages + +on: + # For new release tags pushed into the repository + # The check for the 'main' branch is done on the job level + push: + tags: ["v[0-9]+.[0-9]+.[0-9]+"] + + # Allows to run this workflow manually from the Actions tab + workflow_dispatch: + +# Allow simultaneous checks +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: false + +# Allow this job to clone the repo and create a page deployment +permissions: + contents: read + pages: write + id-token: write + +jobs: + build: + runs-on: ubuntu-latest + if: github.ref == 'refs/heads/main' + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + # with: + # fetch-depth: 0 + - name: Install, build and store site artifact + uses: withastro/action@v3 + with: + path: docs + node-version: 22 + # stores the artifact in docs/dist/ + + deploy: + runs-on: ubuntu-latest + if: github.ref == 'refs/heads/main' + needs: build + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - name: Deploy to GitHub Pages + id: deployment + uses: actions/deploy-pages@v4 + # takes the artifact from docs/dist/ diff --git a/.github/workflows/tact-docs-test.yml b/.github/workflows/tact-docs-test.yml new file mode 100644 index 000000000..e97fdb61d --- /dev/null +++ b/.github/workflows/tact-docs-test.yml @@ -0,0 +1,41 @@ +# To not merge, if build fails +name: Test docs/ build + +on: + # For new PRs, or those who are ready and/or request a review + pull_request: + types: + [ + "opened", + "edited", + "reopened", + "synchronize", + "ready_for_review", + "review_requested", + ] + branches: ["main"] + # Only start the workflow if anything inside the docs has changed + paths: ["docs/**"] + + # Allows to run this workflow manually from the Actions tab + workflow_dispatch: + +# Allow simultaneous checks +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: false + +jobs: + test-build: + runs-on: ubuntu-latest + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + # with: + # fetch-depth: 0 + - name: Install, build and store site artifact + uses: withastro/action@v3 + with: + path: docs + node-version: 22 diff --git a/.npmignore b/.npmignore new file mode 100644 index 000000000..2f8826912 --- /dev/null +++ b/.npmignore @@ -0,0 +1 @@ +/docs diff --git a/.prettierignore b/.prettierignore index 1af3219a2..22b7dfce4 100644 --- a/.prettierignore +++ b/.prettierignore @@ -1,8 +1,8 @@ /dist - /src/func/funcfiftlib.js /src/func/funcfiftlib.wasm.js /src/grammar/grammar.ohm-bundle.d.ts /src/grammar/grammar.ohm-bundle.js /src/imports/stdlib.ts /grammar +/docs diff --git a/.yarnignore b/.yarnignore new file mode 100644 index 000000000..2f8826912 --- /dev/null +++ b/.yarnignore @@ -0,0 +1 @@ +/docs diff --git a/cspell.json b/cspell.json index b91e0a9cb..37816132d 100644 --- a/cspell.json +++ b/cspell.json @@ -147,6 +147,7 @@ "src/test/compilation-fail/fail-const-eval.spec.ts", "src/test/e2e-emulated/getter-names-conflict.spec.ts", "src/test/exit-codes/contracts/compute-phase-errors.tact", - "stdlib/stdlib.fc" + "stdlib/stdlib.fc", + "/docs" ] } diff --git a/docs/.editorconfig b/docs/.editorconfig new file mode 100644 index 000000000..b34921b2b --- /dev/null +++ b/docs/.editorconfig @@ -0,0 +1,12 @@ +root = true + +[*] +indent_style = tab +indent_size = 2 +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = true + +[*.{mdx,md}] +indent_style = space +indent_size = 2 diff --git a/docs/.gitignore b/docs/.gitignore new file mode 100644 index 000000000..043e5f0ba --- /dev/null +++ b/docs/.gitignore @@ -0,0 +1,30 @@ +# build output +dist/ +out/ +# generated types +.astro/ + +# dependencies +node_modules/ +package-lock.json + +# logs +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* + +# environment variables +.env +.env.production + +# macOS-specific files +.DS_Store + +# editors +.vscode/ +.idea/ +.helix/ +.vim/ +.nvim/ +.gitpod.yml diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 000000000..a8260674e --- /dev/null +++ b/docs/README.md @@ -0,0 +1,110 @@ + + + +# Welcome to ⚡ Tact Documentation + +[![Built with Starlight](https://astro.badg.es/v2/built-with-starlight/tiny.svg)](https://starlight.astro.build) + +Hello there! This is the source for the Tact language documentation. + +Latest docs are always available at: [docs.tact-lang.org](https://docs.tact-lang.org). + +Our goal here is to create a welcoming and rich resource that benefits all Tact developers, from beginners to experts. + +## 🌟 Join the Tact community + +Tact is not just a technology; it's a growing community of developers like you! Whether you are just starting out or have tons of experience, your contributions are valuable. + +Here's how you can contribute: + +- Organize or clarify information 📝 +- Make Pull Requests to improve the code or docs 🚀 +- Share tutorials, guides, and articles 📚 + +Join our community chat to stay updated and collaborate: [Tact Telegram community](https://t.me/tactlang) + +## 🤔 How can you contribute? + +Contributing is not just encouraged, it's easy! + +If you've solved a challenging problem or found a better way to explain a complex topic, share it: + +— Got an idea? [Open an issue](https://github.com/tact-lang/tact/issues/new). +— Ready to contribute? [Setup the dev environment](#setup-your-development-environment). + +### ⚙️ Setup your development environment + +Before you submit your amazing contributions, ensure they work seamlessly. + +#### 🌩️ Quick cloud setup + +Use Gitpod for a hassle-free cloud-based IDE experience: + +[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/tact-lang/tact-docs) + +#### 🏠 Local setup + +1. Clone this GitHub repository. +2. Make sure to have the latest version of [Node.js LTS](https://nodejs.org/en/download/) installed. +3. Open your terminal in the project directory. +4. Install dependencies without modifying the `yarn.lock`: + + ``` + yarn deps + ``` + +5. Start your local development server: + + ``` + yarn dev + ``` + +This will open a new browser window displaying your local version of the documentation. Most updates are automatically reflected. + +### 🚀 Project Structure + +Inside of this Astro + Starlight project, you'll see the following folders and files (besides others): + +``` +. +├── public/ +├── src/ +│ ├── assets/ +│ ├── content/ +│ │ ├── docs/ ← HERE ARE ALL THE TACT DOCUMENTATION PAGES +│ │ └── config.ts +│ └── env.d.ts +├── astro.config.mjs +├── package.json +└── tsconfig.json +└── cspell.json +``` + +Starlight looks for `.md` or `.mdx` files in the `src/content/docs/` directory. Each file is exposed as a route based on its file name. The Tact docs use `.mdx` files only. + +Images can be added to `src/assets/` and embedded in MDX files with a relative link. Static assets, like favicons, can be placed in the `public/` directory. + +It's recommended that local images are kept in `src/` whenever possible, so that Astro can transform, optimize and bundle them. Files in the `public/` directory are always served or copied into the build folder as-is, with no processing, and are publicly available by a direct link. + +The local images stored in `src/` can be used by all files in the project: `.astro`, `.md`, `.mdx`, `.mdoc`, and other UI frameworks (if any). Images can be stored in any folder, including alongside your content. + +### 🧞 Commands + +All commands are run from the root of the project, from a terminal: + +| Command | Action +| :------------------------ | :----- +| `yarn deps` | Installs dependencies. +| `yarn dev` | Starts local dev server at `localhost:4321`. +| `yarn build` | Build your production site to `./dist/`. Runs CSpell and also validates all the internal links. +| `yarn preview` | Preview your build locally, before deploying. +| `yarn astro ...` | Run CLI commands like `astro add`, `astro check`, etc. +| `yarn astro -- --help` | Get help using the Astro CLI. + +### 👀 Want to learn more about the framework behind Tact docs? + +Check out [Starlight’s docs](https://starlight.astro.build/), read [the Astro documentation](https://docs.astro.build), or jump into the [Astro Discord server](https://astro.build/chat). + +## License 📄 + +[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) diff --git a/docs/astro.config.mjs b/docs/astro.config.mjs new file mode 100644 index 000000000..0ab2f48b2 --- /dev/null +++ b/docs/astro.config.mjs @@ -0,0 +1,294 @@ +// @ts-check +import { defineConfig } from 'astro/config'; +import starlight from '@astrojs/starlight'; +import fs from 'node:fs'; + +// Allows changing heading ids +import remarkHeadingId from 'remark-custom-heading-id'; + +// Makes heading ids auto-create themselves +import { rehypeHeadingIds } from '@astrojs/markdown-remark'; +import rehypeAutolinkHeadings from 'rehype-autolink-headings'; + +// Adds support for rendering math +import remarkMath from 'remark-math'; +import rehypeKatex from 'rehype-katex'; + +// Adds syntax highlighting for inline code blocks +import rehypeInlineCodeHighlighting from './inline-code-highlighting'; + +// Add validation of internal links during production builds +import starlightLinksValidator from 'starlight-links-validator'; + +// https://astro.build/config +// https://starlight.astro.build/reference/configuration/ +export default defineConfig({ + outDir: './dist', // default, just to be sure + site: 'https://docs.tact-lang.org', + markdown: { + remarkPlugins: [remarkHeadingId, remarkMath], + rehypePlugins: [ + rehypeHeadingIds, + [rehypeAutolinkHeadings, { + behavior: "append", + properties: { + class: "autolink-header", + ariaHidden: true, + tabIndex: -1, + }, + }], + rehypeInlineCodeHighlighting, + rehypeKatex, + ], + }, + integrations: [ + starlight({ + title: { + en: '⚡ Tact Documentation', + 'zh-CN': '⚡ Tact Documentation', + }, + titleDelimiter: '-', + favicon: '/favicon.png', + logo: { + dark: '/public/logo-dark.svg', + light: '/public/logo-light.svg', + alt: '⚡ Tact Documentation', + replacesTitle: true, + }, + // 'head' is auto-populated with SEO-friendly contents + social: { + github: 'https://github.com/tact-lang/tact', + telegram: 'https://t.me/tactlang', + "x.com": 'https://x.com/tact_language', + }, + editLink: { baseUrl: 'https://github.com/tact-lang/tact/edit/main/docs/' }, + tableOfContents: { minHeadingLevel: 2, maxHeadingLevel: 4 }, + expressiveCode: { + themes: ['one-dark-pro', 'one-light'], + useStarlightDarkModeSwitch: true, + useStarlightUiThemeColors: true, + shiki: { + langs: [ + () => JSON.parse(fs.readFileSync('grammars/grammar-tact.json', 'utf-8')), + () => JSON.parse(fs.readFileSync('grammars/grammar-func.json', 'utf-8')), + () => JSON.parse(fs.readFileSync('grammars/grammar-ohm.json', 'utf-8')) + ], + }, + }, + customCss: [ + // To adjust Starlight colors and styles + './src/starlight.custom.css', + // To properly support KaTeX + './src/fonts/katex.fontfaces.css', + './src/katex.min.css', + ], + plugins: [starlightLinksValidator({ + errorOnFallbackPages: false, + // errorOnInvalidHashes: false, + })], + credits: false, + lastUpdated: true, + disable404Route: false, + // Note, that UI translations are bundled by Starlight for many languages: + // https://starlight.astro.build/guides/i18n/#translate-starlights-ui + // + // Also note, that in order to use fallback content and translation notices + // provided by Starlight, files across language folders must be named the same! + defaultLocale: 'root', // removes language prefix from English pages + locales: { + root: { + label: 'English', + lang: 'en', // lang is required for root locales + }, + 'zh-cn': { + label: '简体中文', + lang: 'zh-CN', + }, + }, + // In place of countless meta.js files in old docs: + sidebar: [ + { + label: 'Book', + translations: { + 'zh-CN': '图书', + }, + items: [ + 'book', + { + label: 'Cheatsheets', + translations: { + 'zh-CN': '小抄', + }, + collapsed: true, + autogenerate: { directory: 'book/cs' }, + }, + { + label: 'Fundamentals of Tact', + translations: { 'zn-CN': 'Tact 语言基础' }, + link: '#', attrs: { class: 'sidebar-separator' } + }, + 'book/types', + 'book/integers', + 'book/cells', + 'book/maps', + 'book/structs-and-messages', + 'book/optionals', + 'book/contracts', + 'book/exit-codes', + { + label: 'Expressiveness', + translations: { 'zn-CN': '表现力' }, + link: '#', attrs: { class: 'sidebar-separator' } + }, + 'book/operators', + 'book/expressions', + 'book/statements', + 'book/constants', + 'book/functions', + { + label: 'Communication', + translations: { 'zn-CN': '交流' }, + link: '#', attrs: { class: 'sidebar-separator' } + }, + 'book/receive', + 'book/bounced', + 'book/external', + 'book/lifecycle', + 'book/send', + 'book/message-mode', + { + label: 'Going places', + translations: { 'zn-CN': '前往各地' }, + link: '#', attrs: { class: 'sidebar-separator' } + }, + 'book/deploy', + 'book/debug', + 'book/upgrades', + 'book/import', + 'book/config', + 'book/masterchain', + 'book/func', + 'book/programmatic', + ], + }, + { + label: 'Cookbook', + translations: { + 'zh-CN': '食谱', + }, + items: [ + 'cookbook', + { + label: 'Single contract', + translations: { 'zn-CN': '单一合同' }, + link: '#', attrs: { class: 'sidebar-separator' } + }, + 'cookbook/single-communication', + 'cookbook/type-conversion', + 'cookbook/data-structures', + 'cookbook/algo', + 'cookbook/time', + 'cookbook/access', + 'cookbook/random', + 'cookbook/misc', + { + label: 'Multiple contracts', + translations: { 'zn-CN': '多重合同' }, + link: '#', attrs: { class: 'sidebar-separator' } + }, + 'cookbook/multi-communication', + 'cookbook/jettons', + 'cookbook/nfts', + { + label: 'Decentralized EXchanges (DEXes)', + translations: { + 'zh-CN': '去中心化交易所（DEXes）', + }, + collapsed: true, + autogenerate: { directory: 'cookbook/dexes' } + }, + ], + }, + { + label: 'Reference', + translations: { + 'zh-CN': '参考', + }, + items: [ + 'ref', + 'ref/spec', + { + 'label': 'Evolution', + translations: { + 'zh-CN': '演变', + }, + collapsed: true, + autogenerate: { directory: 'ref/evolution' } + }, + { + label: 'Core library', + translations: { 'zn-CN': '核心图书馆' }, + link: '#', attrs: { class: 'sidebar-separator' } + }, + 'ref/core-base', + 'ref/core-common', + 'ref/core-comptime', + 'ref/core-debug', + 'ref/core-random', + 'ref/core-math', + 'ref/core-strings', + 'ref/core-cells', + 'ref/core-advanced', + { + label: 'Standard libraries', + translations: { 'zn-CN': '标准图书馆' }, + link: '#', attrs: { class: 'sidebar-separator' } + }, + 'ref/standard-libraries', + 'ref/stdlib-config', + 'ref/stdlib-content', + 'ref/stdlib-deploy', + 'ref/stdlib-dns', + 'ref/stdlib-ownable', + 'ref/stdlib-stoppable', + ], + }, + { + label: 'Ecosystem', + translations: { + 'zh-CN': '生态系统', + }, + items: [ + 'ecosystem', + { + label: 'Tools', + translations: { 'zn-CN': '工具' }, + link: '#', attrs: { class: 'sidebar-separator' } + }, + 'ecosystem/typescript', + 'ecosystem/vscode', + 'ecosystem/jetbrains', + 'ecosystem/misti', + ], + }, + { + label: '✈️ Telegram →', + link: 'https://t.me/tactlang', + attrs: { target: '_blank' } + }, + { + label: '🐦 X/Twitter →', + link: 'https://twitter.com/tact_language', + attrs: { target: '_blank' } + } + ], + }), + ], + redirects: { + '/ecosystem/tools/overview': '/ecosystem', + '/ecosystem/tools/typescript': '/ecosystem/typescript', + '/ecosystem/tools/jetbrains': '/ecosystem/jetbrains', + '/ecosystem/tools/vscode': '/ecosystem/vscode', + '/ecosystem/tools/misti': '/ecosystem/misti', + }, +}); diff --git a/docs/cspell.json b/docs/cspell.json new file mode 100644 index 000000000..1f53904be --- /dev/null +++ b/docs/cspell.json @@ -0,0 +1,250 @@ +{ + "$schema": "https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json", + "version": "0.2", + "language": "en", + "words": [ + "ADDRAND", + "BBITS", + "BREFS", + "Brujin", + "CHKSIGNS", + "CHKSIGNU", + "CONFIGOPTPARAM", + "CTOS", + "Cheatsheet", + "Cheatsheets", + "Comptime", + "DEBUGSTR", + "DUEPAYMENT", + "Daniil", + "Decompilation", + "Decompiled", + "Descr", + "Domínguez", + "ENDC", + "Epva", + "Fift", + "Fift", + "GASCONSUMED", + "GETFORWARDFEE", + "GETFORWARDFEESIMPLE", + "GETGASFEE", + "GETGASFEESIMPLE", + "GETORIGINALFWDFEE", + "GETSTORAGEFEE", + "Georgiy", + "HASHCU", + "HASHEXT", + "HASHSU", + "Héctor", + "IPFS", + "Jesús", + "Jetton", + "Jettons", + "KECCAK", + "Komarov", + "Korshakov", + "LDDICT", + "LDIX", + "LDREF", + "LDSLICEX", + "LDUX", + "LDVARUINT", + "LTIME", + "Laika", + "MYADDR", + "Masterchain", + "Merkle", + "NEWC", + "Neovim", + "Nonterminal", + "Novus", + "Offchain", + "Offchain", + "PLDDICT", + "PLDIX", + "PLDREF", + "PLDSLICEX", + "PLDUX", + "POSIX", + "PUSHINT", + "PUSHREF", + "PUSHSLICE", + "Parens", + "RANDU", + "RAWRESERVE", + "RAWRESERVE", + "REWRITESTDADDR", + "REWRITEVARADDR", + "SBITS", + "SDBEGINSQ", + "SDEMPTY", + "SDSKIPFIRST", + "SEMPTY", + "SENDMSG", + "SENDRAWMSG", + "SETCONTARGS", + "SETINDEXVARQ", + "SETNUMARGS", + "SREFS", + "SREMPTY", + "STBR", + "STDICT", + "STIX", + "STON.fi", + "STOPTREF", + "STREF", + "STSLICER", + "STUX", + "STVARUINT", + "Satoshi", + "Seamus", + "Sedov", + "Stateinit", + "Sánchez", + "THROWIFNOT", + "TIMELOCK", + "Tarjan", + "Timeouted", + "Toncoin", + "Toncoins", + "Topup", + "Trunov", + "UBITSIZE", + "Uninit", + "alnum", + "assgn", + "astrojs", + "augmentedassign", + "basechain", + "basechain", + "bitcode", + "bitstring", + "blockstore", + "bounceable", + "bounceable", + "cheatsheet", + "cheatsheets", + "cleanall", + "codegen", + "comptime", + "decompilation", + "decompilation", + "decompile", + "decompiler", + "decompiles", + "decompiles", + "decompiling", + "decompiling", + "dentry", + "disasm", + "divmod", + "dnsresolve", + "dnsresolve", + "elseifnot", + "forall", + "formedness", + "funcfiftlib", + "funcid", + "funs", + "gettest", + "idict", + "infixl", + "infixr", + "initof", + "ipfs", + "ipfs", + "ipld", + "jetton", + "jettons", + "jettons", + "jojo", + "jsxdev", + "keccak", + "knip", + "langle", + "logomark", + "lparen", + "lvalue", + "lvalues", + "masterchain", + "masterchain", + "mathrm", + "maxint", + "minmax", + "mintable", + "mktemp", + "multiformats", + "nanotons", + "nanotons", + "nextra", + "nocheck", + "noexcept", + "nonterminal", + "omelander", + "pinst", + "postpack", + "prando", + "quadtree", + "quadtrees", + "rangle", + "rawslice", + "renamer", + "respecifying", + "rparen", + "rugpull", + "rugpulled", + "sctx", + "seamus", + "seqno", + "seqno", + "seti", + "shardchains", + "shiki", + "stdlib", + "stdlibs", + "stmts", + "struct", + "structs", + "subtyping", + "testdata", + "timeouted", + "typechecker", + "udict", + "uintptr", + "uncons", + "uninit", + "unixfs", + "vogons", + "workchain", + "workchain", + "workchains", + "xffff", + "xtwitter", + "привет", + ], + "ignoreRegExpList": [ + "\\(#.*\\)", + "^\\[.+\\]: .+", // link declarations like [foo]: /ref/stdlib-ownable#bar + "\\[.+\\]\\[.+\\]", // links like [`Resumable{:tact}`][res] + "\\[.+\\]\\(.+\\)", // links like [`self.toCell().asSlice(){:tact}`](/ref/core-cells#cellasslice) + "\\b(?:address|crc32|cell|slice|rawSlice)\\(\".+\"\\)", // Comptime functions + "mathrm\\{.+\\}", // LaTeX subset + "\\[#.+\\]", // [#nativereserve-combining-modes-with-flags] + "\\{#.+\\}", // {#some-other-custom-heading-link} + "href=\".+\"", // href="/cookbook/dexes/stonfi" + "\".+\": \".+\"", // "from": "kQBrSAP2y7QIUw4_1q0qciHfqdFmOYR9CC1oinn7kyWWRuoV" + "Urls" + ], + "flagWords": [], + "ignorePaths": [ + "*.boc", + "*.fif", + "*.func", + "node_modules", + "dist", + "out", + "src/content/docs/ref/spec.mdx", + "src/content/docs/zh-cn" + ] +} diff --git a/docs/grammars/grammar-func.json b/docs/grammars/grammar-func.json new file mode 100644 index 000000000..c9c648480 --- /dev/null +++ b/docs/grammars/grammar-func.json @@ -0,0 +1,117 @@ +{ + "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json", + "name": "func", + "foldingStartMarker": "\\{\\s*$", + "foldingStopMarker": "^\\s*\\}", + "patterns": [ + { + "include": "#keywords" + }, + { + "include": "#strings" + }, + { + "include": "#directives" + }, + { + "include": "#numeric" + }, + { + "include": "#comments" + }, + { + "include": "#storage" + }, + { + "include": "#functions" + }, + { + "include": "#variables" + } + ], + "repository": { + "keywords": { + "patterns": [ + { + "name": "keyword.control.", + "match": "\\b(if|ifnot|else|elseif|elseifnot|while|do|until|repeat|return|impure|method_id|forall|asm|inline|inline_ref)\\b" + }, + { + "name": "keyword.operator", + "match": "(?<=\\s)(<=>|>=|<=|!=|==|\\^>>|\\~>>|>>|<<|\\/%|\\^%|\\~%|\\^\\/|\\~\\/|\\+=|-=|\\*=|\\/=|~\\/=|\\^\\/=|%=|\\^%=|<<=|>>=|~>>=|\\^>>=|&=|\\|=|\\^=|\\^|=|~|\\/|%|-|\\*|\\+|>|<|&|\\||:|\\?)(?=\\s)" + }, + { + "name": "keyword.other", + "match": "\\b(false|true)\\b" + } + ] + }, + "directives": { + "name": "storage.modifier.import", + "begin": "#include|#pragma", + "end": ";", + "patterns": [ + { + "begin": "\"", + "end": "\"", + "name": "string.quoted.double" + }, + { + "match": "(>=|<=|=|>|<|\\^)?([0-9]+)(.[0-9]+)?(.[0-9]+)?", + "name": "constant.numeric" + } + ] + }, + "strings": { + "name": "string.quoted.double.", + "begin": "\"", + "end": "\"(H|h|c|u|s|a)?" + }, + "numeric": { + "name": "constant.numeric", + "match": "(-?([\\d]+|0x[\\da-fA-F]+))\\b" + }, + "comments": { + "patterns": [ + { + "name": "comment.line", + "match": ";;(.*)" + }, + { + "name": "comment.block", + "begin": "{-", + "end": "-}" + } + ] + }, + "storage": { + "patterns": [ + { + "name": "storage.type", + "match": "\\b(var|int|slice|tuple|cell|builder|cont|_)(?=[\\s\\),\\[\\]])" + }, + { + "name": "storage.modifier", + "match": "\\b(global|const)\\s" + } + ] + }, + "variables": { + "patterns": [ + { + "match": "(?!\")(`([^`]+)`|((?=_)_|(?={){|(?=})}|(?![_`{}]))([^;,\\[\\]\\(\\)\\s~.]+))", + "name": "variable.name" + } + ] + }, + "functions": { + "patterns": [ + { + "match": "(?!\")(`([^`]+)`|(\\.|~)?((?=_)_|(?={){|(?=})}|(?![_`{}]))([^;,\\[\\]\\(\\)\\s~.]+))(?=[\\(])", + "name": "entity.name.function" + } + ] + } + }, + "scopeName": "source.func" +} diff --git a/docs/grammars/grammar-ohm.json b/docs/grammars/grammar-ohm.json new file mode 100644 index 000000000..7a9fe979f --- /dev/null +++ b/docs/grammars/grammar-ohm.json @@ -0,0 +1,284 @@ +{ + "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json", + "name": "ohm", + "scopeName": "source.ohm", + "fileTypes": [ + "ohm" + ], + "patterns": [ + { + "include": "#comment" + }, + { + "include": "#grammar" + } + ], + "repository": { + "grammar": { + "patterns": [ + { + "include": "#baseGrammar" + }, + { + "include": "#derivedGrammar" + } + ] + }, + "baseGrammar": { + "begin": "^\\s*([a-zA-Z_]\\w*)\\s*({)", + "beginCaptures": { + "1": { + "name": "entity.name.class" + }, + "2": { + "name": "punctuation.bracket" + } + }, + "patterns": [ + { + "include": "#comment" + }, + { + "include": "#ruleName" + }, + { + "include": "#ruleBody" + } + ], + "end": "}", + "endCaptures": { + "0": { + "name": "punctuation.bracket" + } + } + }, + "derivedGrammar": { + "begin": "^\\s*([a-zA-Z_]\\w*)\\s+(<:)\\s+([a-zA-Z_]\\w*)\\s*({)", + "beginCaptures": { + "1": { + "name": "entity.name.class" + }, + "2": { + "name": "keyword.operator" + }, + "3": { + "name": "entity.other.inherited-class" + }, + "4": { + "name": "punctuation.bracket" + } + }, + "patterns": [ + { + "include": "#comment" + }, + { + "include": "#ruleName" + }, + { + "include": "#ruleBody" + } + ], + "end": "}", + "endCaptures": { + "0": { + "name": "punctuation.bracket" + } + } + }, + "ruleName": { + "begin": "^\\s*([a-zA-Z_]\\w*)", + "beginCaptures": { + "1": { + "name": "entity.name.function" + } + }, + "patterns": [ + { + "include": "#comment" + }, + { + "include": "#formals" + }, + { + "include": "#ruleDescr" + } + ], + "end": "([:+]?=)", + "endCaptures": { + "1": { + "name": "keyword.operator" + } + } + }, + "formals": { + "begin": "(<)", + "beginCaptures": { + "1": { + "name": "punctuation.bracket" + } + }, + "patterns": [ + { + "name": "variable.parameter", + "match": "[a-zA-Z_]\\w*" + }, + { + "name": "punctuation.delimiter", + "match": "," + } + ], + "end": "(>)", + "endCaptures": { + "1": { + "name": "punctuation.bracket" + } + } + }, + "ruleDescr": { + "name": "comment.block.documentation", + "begin": "(\\()", + "beginCaptures": { + "1": { + "name": "punctuation.bracket" + } + }, + "end": "(\\))", + "endCaptures": { + "1": { + "name": "punctuation.bracket" + } + } + }, + "ruleBody": { + "patterns": [ + { + "include": "#comment" + }, + { + "include": "#builtInRulesLexical" + }, + { + "include": "#builtInRulesSyntactic" + }, + { + "include": "#terminal" + }, + { + "include": "#operator" + }, + { + "include": "#punctuation" + }, + { + "include": "#caseName" + } + ] + }, + "builtInRulesLexical": { + "name": "support.function", + "match": "\\b(?:any|alnum|end|digit|hexDigit|letter|space|lower|upper|caseInsensitive|listOf|nonemptyListOf|emptyListOf|applySyntactic)\\b" + }, + "builtInRulesSyntactic": { + "name": "support.function", + "match": "\\b(?:ListOf|NonemptyListOf|EmptyListOf)\\b" + }, + "terminal": { + "name": "string.quoted.double", + "begin": "\"", + "beginCaptures": { + "0": { + "name": "punctuation.definition.string.begin" + } + }, + "patterns": [ + { + "name": "constant.character.escape", + "match": "\\\\(?:x\\h{2}|u\\h{4}|u\\{\\h{1,6}\\}|t|r|n|b|'|\"|\\\\)" + } + ], + "end": "(?:(?|," + }, + { + "name": "punctuation.bracket", + "match": "(|)" + } + ] + }, + "caseName": { + "match": "(--)\\s*([a-zA-Z_]\\w*)", + "captures": { + "1": { + "name": "punctuation.delimiter" + }, + "2": { + "name": "entity.name.tag" + } + } + }, + "comment": { + "patterns": [ + { + "include": "#lineComment" + }, + { + "include": "#blockComment" + } + ] + }, + "lineComment": { + "name": "comment.line", + "begin": "//", + "beginCaptures": { + "0": { + "name": "comment.line.double-slash" + } + }, + "patterns": [ + { + "include": "#todoComment" + } + ], + "end": "$" + }, + "blockComment": { + "name": "comment.block", + "begin": "\\s*/\\*", + "beginCaptures": { + "0": { + "name": "comment.block.begin" + } + }, + "patterns": [ + { + "include": "#todoComment" + } + ], + "end": "\\*/", + "endCaptures": { + "0": { + "name": "comment.block.end" + } + } + }, + "todoComment": { + "name": "keyword.comment.todo", + "match": "(?i)\\b(FIXME|TODO|CHANGED|XXX|IDEA|HACK|NOTE|REVIEW|NB|BUG)\\b" + } + } +} diff --git a/docs/grammars/grammar-tact.json b/docs/grammars/grammar-tact.json new file mode 100644 index 000000000..f4bff6e34 --- /dev/null +++ b/docs/grammars/grammar-tact.json @@ -0,0 +1,604 @@ +{ + "name": "tact", + "displayName": "Tact", + "scopeName": "source.tact", + "fileTypes": [ + "tact" + ], + "foldingStartMarker": "\\{\\s*$", + "foldingStopMarker": "^\\s*\\}", + "patterns": [ + { + "include": "#comment" + }, + { + "include": "#annotation" + }, + { + "include": "#literal" + }, + { + "include": "#invalid" + }, + { + "include": "#constant" + }, + { + "include": "#type" + }, + { + "include": "#expression" + }, + { + "include": "#punctuation" + }, + { + "include": "#keyword" + }, + { + "include": "#function" + }, + { + "include": "#variable" + } + ], + "repository": { + "comment": { + "patterns": [ + { + "name": "comment.line.double-slash.tact", + "begin": "//", + "beginCaptures": { + "0": { + "name": "punctuation.definition.comment.line.double-slash.tact" + } + }, + "patterns": [ + { + "include": "#todo" + } + ], + "end": "$" + }, + { + "name": "comment.block.tact", + "begin": "\\s*/\\*", + "beginCaptures": { + "0": { + "name": "comment.block.begin.tact punctuation.definition.comment.begin.tact" + } + }, + "patterns": [ + { + "include": "#todo" + } + ], + "end": "\\*/", + "endCaptures": { + "0": { + "name": "comment.block.end.tact punctuation.definition.comment.end.tact" + } + } + } + ] + }, + + "todo": { + "match": "(?i)\\b(FIXME|TODO|CHANGED|XXX|IDEA|HACK|NOTE|REVIEW|NB|BUG)\\b(?-i)", + "name": "keyword.comment.todo.tact" + }, + + "annotation": { + "patterns": [ + { + "comment": "@name() in native functions", + "begin": "^\\s*(@name)\\s*(\\()", + "beginCaptures": { + "1": { + "name": "entity.other.attribute-name.tact" + }, + "2": { + "name": "punctuation.brackets.round.tact" + } + }, + "patterns": [ + { + "comment": "FunC identifier", + "match": "(.*?)", + "name": "entity.name.function.func.tact" + } + ], + "end": "\\)", + "endCaptures": { + "0": { + "name": "punctuation.brackets.round.tact" + } + } + }, + { + "comment": "One or more @inteface() before traits and contracts", + "begin": "(?", + "name": "keyword.operator.mapsto.tact" + }, + { + "match": "\\b([0-9]*)\\b", + "name": "constant.numeric.decimal.tact" + } + ], + "end": "\\)", + "endCaptures": { + "0": { + "name": "punctuation.brackets.round.tact" + } + } + }, + { + "comment": "Fallback match", + "match": "(?", + "begin": "(?", + "endCaptures": { + "0": { + "name": "punctuation.brackets.angle.tact" + } + } + }, + { + "comment": "map", + "begin": "(?", + "endCaptures": { + "0": { + "name": "punctuation.brackets.angle.tact" + } + } + }, + { + "include": "#as-tlb" + } + ] + }, + + "simple-type": { + "comment": "Simple types", + "match": "(?>)(?!=)", + "name": "keyword.operator.bitwise.tact" + }, + { + "comment": "Augmented assignment operators", + "match": "(\\+=|-=|\\*=|/=|%=|\\^=|&=|\\|=|<<=|>>=)", + "name": "keyword.operator.assignment.tact" + }, + { + "comment": "Assignment operator", + "match": "(?])=(?!=)", + "name": "keyword.operator.assignment.equal.tact" + }, + { + "comment": "Comparison operators", + "match": "([!=]=|<=?|>=?)", + "name": "keyword.operator.comparison.tact" + }, + { + "comment": "Arithmetic operators", + "match": "([+%*\\-])|(/(?!/))", + "name": "keyword.operator.arithmetic.tact" + }, + { + "comment": "initOf expression", + "match": "\\b(initOf)\\b", + "name": "keyword.operator.new.tact" + }, + { + "comment": "Ternary expression", + "begin": "(?!\\?\\.\\s*[^[:digit:]])(\\?)(?!\\?)", + "beginCaptures": { + "1": { + "name": "keyword.operator.ternary.tact" + } + }, + "patterns": [ + { + "include": "$self" + } + ], + "end": "\\s*(:)", + "endCaptures": { + "1": { + "name": "keyword.operator.ternary.tact" + } + } + } + ] + }, + + "punctuation": { + "patterns": [ + { + "match": ",", + "name": "punctuation.comma.tact" + }, + { + "match": "[{}]", + "name": "punctuation.brackets.curly.tact" + }, + { + "match": "[()]", + "name": "punctuation.brackets.round.tact" + }, + { + "match": ";", + "name": "punctuation.semi.tact" + }, + { + "match": ":", + "name": "punctuation.colon.tact" + }, + { + "match": "\\.", + "name": "punctuation.dot.tact" + } + ] + }, + + "keyword": { + "patterns": [ + { + "match": "(? + + + + + + + + + + + + + + + + + + + + diff --git a/docs/public/logo-light.svg b/docs/public/logo-light.svg new file mode 100644 index 000000000..ab3fed54a --- /dev/null +++ b/docs/public/logo-light.svg @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/public/logomark-dark.svg b/docs/public/logomark-dark.svg new file mode 100644 index 000000000..38a9c53da --- /dev/null +++ b/docs/public/logomark-dark.svg @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/public/logomark-light.svg b/docs/public/logomark-light.svg new file mode 100644 index 000000000..01d027594 --- /dev/null +++ b/docs/public/logomark-light.svg @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/src/content/config.ts b/docs/src/content/config.ts new file mode 100644 index 000000000..31d79b34b --- /dev/null +++ b/docs/src/content/config.ts @@ -0,0 +1,7 @@ +import { defineCollection } from 'astro:content'; +import { docsSchema } from '@astrojs/starlight/schema'; + +export const collections = { + docs: defineCollection({ schema: docsSchema() }), + // 'dev-docs': defineCollection({ schema: docsSchema() }), +}; diff --git a/docs/src/content/docs/book/bounced.mdx b/docs/src/content/docs/book/bounced.mdx new file mode 100644 index 000000000..4be704fab --- /dev/null +++ b/docs/src/content/docs/book/bounced.mdx @@ -0,0 +1,37 @@ +--- +title: Bounced messages +--- + +When a contract sends a message with a flag `bounce` set to `true{:tact}`, then if the message wasn't processed properly, it would bounce back to the sender. This is useful when you want to make sure that the message was processed properly and if not — revert the changes. + +## Caveats + +Currently, bounced messages in TON have only 224 usable data bits in the message body and don't have any references. This means that you can't recover much of the data from the bounced message. This is a limitation of the TON blockchain and will be fixed in the future. Tact helps you to check if your message fits the limit and in case it doesn't — suggests using a special type constructor `bounced{:tact}` for the bounced message receiver, that would construct a partial representation of the message that fits into the required limits. + +## Bounced message receiver + +:::caution + + Bounced text messages are not supported yet. + +::: + +To receive a bounced message, define a `bounced(){:tact}` [receiver function](/book/contracts#receiver-functions) in your [contract](/book/contracts) or a [trait](/book/types#traits): + +```tact {2-4} +contract MyContract { + bounced(msg: bounced) { + // ... + } +} +``` + +To process bounced messages manually, you can use a fallback definition that handles a raw [`Slice{:tact}`](/book/cells#slices) directly. Note, that such receiver will get **all** the bounced messages produced by your contract: + +```tact /rawMsg: Slice/ +contract MyContract { + bounced(rawMsg: Slice) { + // ... + } +} +``` diff --git a/docs/src/content/docs/book/cells.mdx b/docs/src/content/docs/book/cells.mdx new file mode 100644 index 000000000..3e39134ca --- /dev/null +++ b/docs/src/content/docs/book/cells.mdx @@ -0,0 +1,445 @@ +--- +title: Cells, Builders and Slices +--- + +[Cells](#cells), [Builders](#builders) and [Slices](#slices) are low-level [primitives][p] of TON Blockchain. The virtual machine of TON Blockchain, [TVM][tvm], uses cells to represent all data structures in persistent storage, and most in memory. + +## Cells + +`Cell{:tact}` is a [primitive][p] and a data structure, which [ordinarly](#cells-kinds) consists of up to $1023$ continuously laid out bits and up to $4$ references (refs) to other cells. Circular references are forbidden and cannot be created by the means of [TVM][tvm], which means cells can be viewed as [quadtrees][quadtree] or [directed acyclic graphs (DAGs)](https://en.wikipedia.org/wiki/Directed_acyclic_graph) of themselves. Contract code itself is represented by a tree of cells. + +Cells and [cell primitives](#cells-immutability) are bit-oriented, not byte-oriented: [TVM][tvm] regards data kept in cells as sequences (strings or streams) of up to $1023$ bits, not bytes. If necessary, contracts are free to use, say, $21$-bit integer fields serialized into [TVM][tvm] cells, thus using fewer persistent storage bytes to represent the same data. + +### Kinds {#cells-kinds} + +While the [TVM][tvm] type [`Cell{:tact}`](#cells) refers to all cells, there are different cell kinds with various memory layouts. The one described [earlier](#cells) is commonly referred to as an _ordinary_ (or simple) cell — that's the most simple and most commonly used flavor of cells, which can only contain data. The grand majority of descriptions, guides and [references](/ref/core-cells) to cells and their usage assumes ordinary ones. + +Other kinds of cells are collectively called _exotic_ (or special) cells. They sometimes appear in actual representations of blocks and other data structures on TON Blockchain. Their memory layouts and purposes significantly differ from ordinary cells. + +Kinds (or subtypes) of all cells are encoded by an integer between $-1$ and $255$. Ordinary cells are encoded by $-1$, while exotic ones can be encoded by any other integer in that range. The subtype of an exotic cell is stored in the first $8$ bits of its data, which means valid exotic cells always have at least $8$ data bits. + +[TVM][tvm] currently supports the following exotic cell subtypes: +* [Pruned branch cell][c-pruned], with subtype encoded as $1$ — they represent deleted subtrees of cells. +* [Library reference cell][c-library], with subtype encoded as $2$ — they are used for storing libraries, and usually, in [masterchain](/book/masterchain) contexts. +* [Merkle proof cell][c-mproof], with subtype encoded as $3$ — they are used for verifying that certain portions of other cell's tree data belong to the full tree. +* [Merkle update cell][c-mupdate], with subtype encoded as $4$ — they always have two references and behave like a [Merkle proof][mproof] for both of them. + +:::note[Useful links:] + + [Pruned branch cells in TON Docs][c-pruned]\ + [Library reference cells in TON Docs][c-library]\ + [Merkle proof cells in TON Docs][c-mproof]\ + [Merkle update cells in TON Docs][c-mupdate]\ + [Simple proof-verifying example in TON Docs][mproof] + +::: + +[c-pruned]: https://docs.ton.org/develop/data-formats/exotic-cells#pruned-branch +[c-library]: https://docs.ton.org/develop/data-formats/library-cells +[c-mproof]: https://docs.ton.org/develop/data-formats/exotic-cells#merkle-proof +[c-mupdate]: https://docs.ton.org/develop/data-formats/exotic-cells#merkle-update +[mproof]: https://docs.ton.org/develop/data-formats/exotic-cells#simple-proof-verifying-example + +### Levels {#cells-levels} + +Every cell, being a [quadtree][quadtree], has an attribute called _level_, which is represented by an integer between $0$ and $3$. The level of an [ordinary](#cells-kinds) cell is always equal to the maximum of the levels of all its references. That is, level of an ordinary cell without references is equal to $0$. + +[Exotic](#cells-kinds) cells have different rules for determining their level, which are described [on this page in TON Docs](https://docs.ton.org/develop/data-formats/exotic-cells). + +### Serialization {#cells-serialization} + +Before a cell can be transferred over the network or stored on disk, it must be serialized. There are several common formats, such as [standard `Cell{:tact}` representation](#cells-representation) and [BoC](#cells-boc). + +#### Standard representation {#cells-representation} + +Standard [`Cell{:tact}`](#cells) representation is a common serialization format for cells first described in the [tvm.pdf](https://docs.ton.org/tvm.pdf). Its algorithm representing cells in octet (byte) sequences begins with serializing the first $2$ bytes called descriptors: + +* _Refs descriptor_ is calculated according to this formula: $r + 8 * k + 32 * l$, where $r$ is the number of references contained in the cell (between $0$ and $4$), $k$ is a flag for the cell kind ($0$ for [ordinary](#cells-kinds) and $1$ for [exotic](#cells-kinds)), and $l$ is the [level](#cells-levels) of the cell (between $0$ and $3$). +* _Bits descriptor_ is calculated according to this formula $\lfloor\frac{b}{8}\rfloor + \lceil\frac{b}{8}\rceil$, where $b$ is the number of bits in the cell (between $0$ and $1023$). + +Then, the data bits of the cell themselves are serialized as $\lceil\frac{b}{8}\rceil$ $8$-bit octets (bytes). If $b$ is not a multiple of eight, a binary $1$ and up to six binary $0$s are appended to the data bits. + +Next, the $2$ bytes store the depth of the refs, i.e. the number of cells between the root of the cell tree (the current cell) and the deepest of the references, including it. For example, a cell containing only one reference and no further references would have a depth of $1$, while the referenced cell would have a depth of $0$. + +Finally, for every reference cell the [SHA-256][sha-2] hash of its standard representation is stored, occupying $32$ bytes per each such cell and recursively repeating the said algorithm. Notice, that cyclic cell references are not allowed, so this recursion always ends in a well-defined manner. + +If we were to compute the hash of the standard representation of this cell, all the bytes from steps above would be concatenated together and then hashed using [SHA-256][sha-2] hash. This is the algorithm behind [`HASHCU` and `HASHSU` instructions](https://docs.ton.org/learn/tvm-instructions/instructions) of [TVM][tvm] and respective [`Cell.hash(){:tact}`](/ref/core-cells#cellhash) and [`Slice.hash(){:tact}`](/ref/core-cells#slicehash) functions of Tact. + +#### Bag of Cells {#cells-boc} + +Bag of Cells, or _BoC_ for short, is a format for serializing and de-serializing cells into byte arrays as described in [boc.tlb](https://github.com/ton-blockchain/ton/blob/24dc184a2ea67f9c47042b4104bbb4d82289fac1/crypto/tl/boc.tlb#L25) [TL-B schema][tlb]. + +Read more about BoC in TON Docs: [Bag of Cells](https://docs.ton.org/develop/data-formats/cell-boc#bag-of-cells). + +:::note + + Advanced information on [`Cell{:tact}`](#cells) serialization: [Canonical `Cell{:tact}` Serialization](https://docs.ton.org/develop/research-and-development/boc). + +::: + +### Immutability {#cells-immutability} + +Cells are read-only and immutable, but there are two major sets of [ordinary](#cells-kinds) cell manipulation instructions in [TVM][tvm]: + +* Cell creation (or serialization) instructions, which are used to construct new cells from previously kept values and cells; +* And cell parsing (or deserialization) instructions, which are used to extract or load data previously stored into cells via serialization instructions. + +On top of that, there are instructions specific to [exotic](#cells-kinds) cells to create them and expect their values. However, [ordinary](#cells-kinds) cell parsing instructions can still be used on [exotic](#cells-kinds) ones, in which case they are automatically replaced by [ordinary](#cells-kinds) cells during such deserialization attempts. + +All cell manipulation instructions require transforming values of [`Cell{:tact}`](#cells) type to either [`Builder{:tact}`](#builders) or [`Slice{:tact}`](#slices) types before such cells can be modified or inspected. + +## Builders + +`Builder{:tact}` is a cell manipulation [primitive][p] for using cell creation instructions. They're immutable just like cells are, and allow constructing new cells from previously kept values and cells. Unlike cells, values of type `Builder{:tact}` appear only on [TVM][tvm] stack and cannot be stored in persistent storage. That means, for example, that persistent storage fields with type `Builder{:tact}` would actually be stored as cells under the hood. + +`Builder{:tact}` type represents partially composed cells, for which fast operations for appending integers, other cells, references to other cells and many others are defined: + +* [`Builder.storeUint(){:tact}` in Core library][b-2] +* [`Builder.storeInt(){:tact}` in Core library][b-3] +* [`Builder.storeBool(){:tact}` in Core library][b-4] +* [`Builder.storeSlice(){:tact}` in Core library][b-5] +* [`Builder.storeCoins(){:tact}` in Core library][b-6] +* [`Builder.storeAddress(){:tact}` in Core library][b-7] +* [`Builder.storeRef(){:tact}` in Core library][b-8] + +While you may use them for [manual construction](#cnp-manually) of the cells, it's strongly recommended to use [Structs][struct] instead: [Construction of cells with Structs](#cnp-structs). + +## Slices + +`Slice{:tact}` is a cell manipulation [primitive][p] for using cell parsing instructions. Unlike cells, they're mutable and allow extracting or loading data previously stored into cells via serialization instructions. Also unlike cells, values of type `Slice{:tact}` appear only on [TVM][tvm] stack and cannot be stored in persistent storage. That means, for example, that persistent storage fields with type `Slice{:tact}` would actually be stored as cells under the hood. + +`Slice{:tact}` type represents either the remainder of a partially parsed cell, or a value (subcell) residing inside such a cell and extracted from it by a parsing instruction: + +* [`Slice.loadUint(){:tact}` in Core library][s-2] +* [`Slice.loadInt(){:tact}` in Core library][s-3] +* [`Slice.loadBool(){:tact}` in Core library][s-4] +* [`Slice.loadBits(){:tact}` in Core library][s-5] +* [`Slice.loadCoins(){:tact}` in Core library][s-6] +* [`Slice.loadAddress(){:tact}` in Core library][s-7] +* [`Slice.loadRef(){:tact}` in Core library][s-8] + +While you may use them for [manual parsing](#cnp-manually) of the cells, it's strongly recommended to use [Structs][struct] instead: [Parsing of cells with Structs](#cnp-structs). + +## Serialization types + +Similar to serialization options of [`Int{:tact}`](/book/integers) type, `Cell{:tact}`, `Builder{:tact}` and `Slice{:tact}` also have various representations for encoding their values in the following cases: + +* as [storage variables](/book/contracts#variables) of [contracts](/book/contracts) and [traits](/book/types#traits), +* and as fields of [Structs](/book/structs-and-messages#structs) and [Messages](/book/structs-and-messages#messages). + +```tact {2-3} +contract SerializationExample { + someCell: Cell as remaining; + someSlice: Slice as bytes32; + + // Constructor function, + // necessary for this example contract to compile + init() { + self.someCell = emptyCell(); + self.someSlice = beginCell().storeUint(42, 256).asSlice(); + } +} +``` + +### `remaining` {#serialization-remaining} + +The `remaining{:tact}` serialization option can be applied to values of [`Cell{:tact}`](#cells), [`Builder{:tact}`](#builders) and [`Slice{:tact}`](#slices) types. + +It affects the process of constructing and parsing cell values by causing them to be stored and loaded directly rather than as a reference. To draw parallels with [cell manipulation instructions](#cells-immutability), specifying `remaining{:tact}` is like using [`Builder.storeSlice(){:tact}`][b-5] and [`Slice.loadBits(){:tact}`][s-5] instead of [`Builder.storeRef(){:tact}`][b-8] and [`Slice.loadRef(){:tact}`][s-8], which are to be used by default. + +In addition, the [TL-B][tlb] representation produced by Tact changes too: + +```tact {3-5, 8-10} +contract SerializationExample { + // By default + cRef: Cell; // ^cell in TL-B + bRef: Builder; // ^builder in TL-B + sRef: Slice; // ^slice in TL-B + + // With `remaining` + cRem: Cell as remaining; // remainder in TL-B + bRem: Builder as remaining; // remainder in TL-B + sRem: Slice as remaining; // remainder in TL-B + + // Constructor function, + // necessary for this example contract to compile + init() { + self.cRef = emptyCell(); + self.bRef = beginCell(); + self.sRef = emptySlice(); + self.cRem = emptyCell(); + self.bRem = beginCell(); + self.sRem = emptySlice(); + } +} +``` + +There, `^cell`, `^builder` and `^slice` in [TL-B][tlb] syntax mean the reference to [`Cell{:tact}`](#cells), [`Builder{:tact}`](#builders) and [`Slice{:tact}`](#slices) values respectively, while the `remainder<…>` of `cell`, `builder` or `slice` tells that the given value would be stored as a `Slice{:tact}` directly and not as a reference. + +Now, to give a real-world example, imagine that you need to notice and react to inbound [jetton][jetton] transfers in your smart contract. The appropriate [Message][message] structure for doing so would look something like this: + +```tact /remaining/ +message(0x7362d09c) JettonTransferNotification { + queryId: Int as uint64; // arbitrary request number to prevent replay attacks + amount: Int as coins; // amount of jettons transferred + sender: Address; // address of the sender of the jettons + forwardPayload: Slice as remaining; // optional custom payload +} +``` + +And the [receiver][recv] in the contract would look like this: + +```tact +receive(msg: JettonTransferNotification) { + // ... you do you ... +} +``` + +Upon receiving a [jetton][jetton] transfer notification message, its cell body is converted into a [`Slice{:tact}`](#slices) and then parsed as a `JettonTransferNotification{:tact}` [Message][message]. At the end of this process, the `forwardPayload` will have all the remaining data of the original message cell. + +Here, it's not possible to violate the [jetton][jetton] standard by placing the `forwardPayload: Slice as remaining` field in any other position in the `JettonTransferNotification{:tact}` [Message][message]. That's because Tact prohibits usage of `as remaining{:tact}` for any but the last field of the [Structs][struct] and [Messages][message] to prevent misuse of the contract storage and reduce gas consumption. + +:::note + + Note, that the cell serialized via `as remaining{:tact}` cannot be [optional](/book/optionals). That is, specifying something like `Cell? as remaining{:tact}`, `Builder? as remaining{:tact}` or `Slice? as remaining{:tact}` would cause a compilation error. + + Also note, that specifying `remaining{:tact}` for the `Cell{:tact}` as the [map](/book/maps) value type is considered an error and it won't compile. + +::: + +### `bytes32` {#serialization-bytes64} + +:::note + + To be resolved by [#94](https://github.com/tact-lang/tact-docs/issues/94). + +::: + +### `bytes64` {#serialization-bytes64} + +:::note + + To be resolved by [#94](https://github.com/tact-lang/tact-docs/issues/94). + +::: + +## Operations + +### Construct and parse {#operations-cnp} + +In Tact, there are at least two ways to construct and parse cells: + +* [Manually](#cnp-manually), which involves active use of [`Builder{:tact}`](#builders), [`Slice{:tact}`](#slices) and [relevant methods](/ref/core-cells). +* [Using Structs](#cnp-structs), which is a recommended and much more convenient approach. + +#### Manually {#cnp-manually} + +Construction via `Builder{:tact}` | Parsing via `Slice{:tact}` +:------------------------------------- | :------------------------- +[`beginCell(){:tact}`][b-1] | [`Cell.beginParse(){:tact}`][s-1] +[`.storeUint(42, 7){:tact}`][b-2] | [`Slice.loadUint(7){:tact}`][s-2] +[`.storeInt(42, 7){:tact}`][b-3] | [`Slice.loadInt(7){:tact}`][s-3] +[`.storeBool(true){:tact}`][b-4] | [`Slice.loadBool(true){:tact}`][s-4] +[`.storeSlice(slice){:tact}`][b-5] | [`Slice.loadBits(slice){:tact}`][s-5] +[`.storeCoins(42){:tact}`][b-6] | [`Slice.loadCoins(42){:tact}`][s-6] +[`.storeAddress(address){:tact}`][b-7] | [`Slice.loadAddress(){:tact}`][s-7] +[`.storeRef(cell){:tact}`][b-8] | [`Slice.loadRef(){:tact}`][s-8] +[`.endCell(){:tact}`][b-9] | [`Slice.endParse(){:tact}`][s-9] + +[b-1]: /ref/core-cells#begincell +[b-2]: /ref/core-cells#builderstoreuint +[b-3]: /ref/core-cells#builderstoreint +[b-4]: /ref/core-cells#builderstorebool +[b-5]: /ref/core-cells#builderstoreslice +[b-6]: /ref/core-cells#builderstorecoins +[b-7]: /ref/core-cells#builderstoreaddress +[b-8]: /ref/core-cells#builderstoreref +[b-9]: /ref/core-cells#builderendcell +[s-1]: /ref/core-cells#cellbeginparse +[s-2]: /ref/core-cells#sliceloaduint +[s-3]: /ref/core-cells#sliceloadint +[s-4]: /ref/core-cells#sliceloadbool +[s-5]: /ref/core-cells#sliceloadbits +[s-6]: /ref/core-cells#sliceloadcoins +[s-7]: /ref/core-cells#sliceloadaddress +[s-8]: /ref/core-cells#sliceloadref +[s-9]: /ref/core-cells#sliceendparse + +#### Using Structs (recommended) {#cnp-structs} + +[Structs][struct] and [Messages][message] are almost like living [TL-B schemas][tlb]. Which means that they're, essentially, [TL-B schemas][tlb] expressed in maintainable, verifiable and user-friendly Tact code. + +It is strongly recommended to use them and their [methods](/book/functions#extension-function) like [`Struct.toCell(){:tact}`][st-tc] and [`Struct.fromCell(){:tact}`][st-fc] instead of manually constructing and parsing cells, as this allows for much more declarative and self-explanatory contracts. + +The examples of manual parsing [above](#cnp-manually) could be re-written using [Structs][struct], with descriptive names of fields if one so desires: + +```tact /fromCell/ /toCell/ +// First Struct +struct Showcase { + id: Int as uint8; + someImportantNumber: Int as int8; + isThatCool: Bool; + payload: Slice; + nanoToncoins: Int as coins; + wackyTacky: Address; + jojoRef: Adventure; // another Struct +} + +// Here it is +struct Adventure { + bizarre: Bool = true; + time: Bool = false; +} + +fun example() { + // Basics + let s = Showcase.fromCell( + Showcase{ + id: 7, + someImportantNumber: 42, + isThatCool: true, + payload: emptySlice(), + nanoToncoins: 1330 + 7, + wackyTacky: myAddress(), + jojoRef: Adventure{ bizarre: true, time: false }, + }.toCell()); + s.isThatCool; // true +} +``` + +Note, that Tact's auto-layout algorithm is greedy. For example, `struct Adventure{:tact}` occupies very little space, and it won't be stored as a reference [`Cell{:tact}`](#cells), but will be provided directly as a [`Slice{:tact}`](#slices). + +By using [Structs][struct] and [Messages][message] over manual [`Cell{:tact}`](#cells) composition and parsing, those details would be simplified away and won't cause any hassle when the optimized layout changes. + +:::note[Useful links:] + + [Convert serialization](/book/func#convert-serialization)\ + [`Struct.toCell(){:tact}` in Core library][st-tc]\ + [`Struct.fromCell(){:tact}` in Core library][st-fc]\ + [`Struct.fromSlice(){:tact}` in Core library][st-fs]\ + [`Message.toCell(){:tact}` in Core library][msg-tc]\ + [`Message.fromCell(){:tact}` in Core library][msg-fc]\ + [`Message.fromSlice(){:tact}` in Core library][msg-fs] + +::: + +[st-tc]: /ref/core-cells#structtocell +[st-fc]: /ref/core-cells#structfromcell +[st-fs]: /ref/core-cells#structfromslice +[msg-tc]: /ref/core-cells#messagetocell +[msg-fc]: /ref/core-cells#messagefromcell +[msg-fs]: /ref/core-cells#messagefromslice + +### Check if empty {#operations-empty} + +Neither [`Cell{:tact}`](#cells) nor [`Builder{:tact}`](#builders) can be checked for emptiness directly — one needs to convert them to [`Slice{:tact}`](#slices) first. + +To check if there are any bits, use [`Slice.dataEmpty(){:tact}`][s-de]. To check if there are any references, use [`Slice.refsEmpty(){:tact}`][s-re]. And to check both at the same time, use [`Slice.empty(){:tact}`][s-e]. + +To also throw an [exit code 9](/book/exit-codes#9) whenever the [`Slice{:tact}`](#slices) isn't completely empty, use [`Slice.endParse(){:tact}`][s-ep]. + +```tact +// Preparations +let someCell = beginCell().storeUint(42, 7).endCell(); +let someBuilder = beginCell().storeRef(someCell); + +// Obtaining our Slices +let slice1 = someCell.asSlice(); +let slice2 = someBuilder.asSlice(); + +// .dataEmpty() +slice1.dataEmpty(); // false +slice2.dataEmpty(); // true + +// .refsEmpty() +slice1.refsEmpty(); // true +slice2.refsEmpty(); // false + +// .empty() +slice1.empty(); // false +slice2.empty(); // false + +// .endParse() +try { + slice1.endParse(); + slice2.endParse(); +} catch (e) { + e; // 9 +} +``` + +:::note[Useful links:] + + [`Cell.asSlice(){:tact}` in Core library](/ref/core-cells#cellasslice)\ + [`Builder.asSlice(){:tact}` in Core library](/ref/core-cells#builderasslice)\ + [`Slice.dataEmpty(){:tact}` in Core library][s-de]\ + [`Slice.refsEmpty(){:tact}` in Core library][s-re]\ + [`Slice.empty(){:tact}` in Core library][s-e]\ + [`Slice.endParse(){:tact}` in Core library][s-ep] + +::: + +[s-de]: /ref/core-cells#slicedataempty +[s-re]: /ref/core-cells#slicerefsempty +[s-e]: /ref/core-cells#sliceempty +[s-ep]: /ref/core-cells#sliceendparse + +### Check if equal {#operations-equal} + +Values of type [`Builder{:tact}`](#builders) cannot be compared directly using binary equality [`=={:tact}`][bin-eq] or inequality [`!={:tact}`][bin-eq] operators. However, values of type [`Cell{:tact}`](#cells) and [`Slice{:tact}`](#slices) can. + +Direct comparisons: + +```tact +let a = beginCell().storeUint(123, 8).endCell(); +let aSlice = a.asSlice(); + +let b = beginCell().storeUint(123, 8).endCell(); +let bSlice = b.asSlice(); + +let areCellsEqual = a == b; // true +let areCellsNotEqual = a != b; // false + +let areSlicesEqual = aSlice == bSlice; // true +let areSlicesNotEqual = aSlice != bSlice; // false +``` + +Note, that direct comparison via `=={:tact}` or `!={:tact}` operators implicitly uses [SHA-256](https://en.wikipedia.org/wiki/SHA-2#Hash_standard) hashes of [standard `Cell{:tact}` representation](#cells-representation) under the hood. + +Explicit comparisons using `.hash(){:tact}` are also available: + +```tact +let a = beginCell().storeUint(123, 8).endCell(); +let aSlice = a.asSlice(); + +let b = beginCell().storeUint(123, 8).endCell(); +let bSlice = b.asSlice(); + +let areCellsEqual = a.hash() == b.hash(); // true +let areCellsNotEqual = a.hash() != b.hash(); // false + +let areSlicesEqual = aSlice.hash() == bSlice.hash(); // true +let areSlicesNotEqual = aSlice.hash() != bSlice.hash(); // false +``` + +:::note[Useful links:] + + [`Cell.hash(){:tact}` in Core library](/ref/core-cells#cellhash)\ + [`Slice.hash(){:tact}` in Core library](/ref/core-cells#slicehash)\ + [`=={:tact}` and `!={:tact}`][bin-eq] + +::: + +[p]: /book/types#primitive-types +[struct]: /book/structs-and-messages#structs +[message]: /book/structs-and-messages#messages +[recv]: /book/contracts#receiver-functions + +[tvm]: https://docs.ton.org/learn/tvm-instructions/tvm-overview +[tlb]: https://docs.ton.org/develop/data-formats/tl-b-language +[jetton]: https://docs.ton.org/develop/dapps/asset-processing/jettons +[sha-2]: https://en.wikipedia.org/wiki/SHA-2#Hash_standard + +[quadtree]: https://en.wikipedia.org/wiki/Quadtree +[bin-eq]: /book/operators#binary-equality + diff --git a/docs/src/content/docs/book/config.mdx b/docs/src/content/docs/book/config.mdx new file mode 100644 index 000000000..10e8a838d --- /dev/null +++ b/docs/src/content/docs/book/config.mdx @@ -0,0 +1,414 @@ +--- +title: Configuration +--- + +The behavior of Tact compiler can be customized using its configuration file, `tact.config.json` — a JSON file that contains the list of settings according to the specific [schema](#schema). + +This page lists all of the configuration options as they're structured in the [schema](#schema). Look for table of contents on the right to easily navigate them. + +:::note + + The only requirement for that file is to be a valid JSON with [proper fields](#schema), so it can be named arbitrarily. However, naming your config file as `tact.config.json` is a common convention encouraged and supported by all tools working with Tact. + +::: + +## `$schema` {#schema} + +A [JSON schema](https://json-schema.org/) file is available for editors to provide autocompletion and hover hints: [configSchema.json](http://raw.githubusercontent.com/tact-lang/tact/main/schemas/configSchema.json). + +Simply add the `$schema` field on top your configuration file: + +```json filename="tact.config.json" {2} +{ + "$schema": "http://raw.githubusercontent.com/tact-lang/tact/main/schemas/configSchema.json", + "projects": [] +} +``` + +## `projects` {#projects} + +List of Tact projects with respective compilation options. Each `.tact` file represents its own Tact project. + +```json filename="tact.config.json" {3,4} +{ + "projects": [ + { }, + { } + ] +} +``` + +### `name` {#projects-name} + +Name of the project. All generated files are prefixed with it. + +In [Blueprint][bp], `name` refers to the name of the contract itself. + +```json filename="tact.config.json" {4,7} +{ + "projects": [ + { + "name": "some_prefix" + }, + { + "name": "ContractUnderBlueprint" + } + ] +} +``` + +### `path` {#projects-path} + +Path to the project's Tact file. You can only specify one Tact file per project. + +In [Blueprint][bp], `path` is superseded by the `target` field in `wrappers/ContractName.compile.ts`. + +```json filename="tact.config.json" {5} +{ + "projects": [ + { + "name": "some_prefix", + "path": "./contract.tact" + } + ] +} +``` + +### `output` {#projects-output} + +Path to the directory where all generated files will be placed. + +In [Blueprint][bp], `output` is not used and all generated files are always placed in `build/ProjectName/`. + +```json filename="tact.config.json" {6} +{ + "projects": [ + { + "name": "some_prefix", + "path": "./contract.tact", + "output": "./contract_output" + } + ] +} +``` + +### `options` {#projects-options} + +Compilation options for the project. + +In [Blueprint][bp], they act as default unless modified in `wrappers/ContractName.compile.ts`. + +```json filename="tact.config.json" {7,11} +{ + "projects": [ + { + "name": "some_prefix", + "path": "./contract.tact", + "output": "./contract_output", + "options": {} + }, + { + "name": "ContractUnderBlueprint", + "options": {} + } + ] +} +``` + +#### `debug` {#options-debug} + +`false{:json}` by default. + +If set to `true{:json}`, enables debug output of a contract and allows usage of [`dump(){:tact}`](/ref/core-debug#dump) function, which is useful for [debugging purposes](/book/debug). With this option enabled, the contract will report that it was compiled in debug mode using the `supported_interfaces` method. + +```json filename="tact.config.json" {8,14} +{ + "projects": [ + { + "name": "some_prefix", + "path": "./contract.tact", + "output": "./contract_output", + "options": { + "debug": true + } + }, + { + "name": "ContractUnderBlueprint", + "options": { + "debug": true + } + } + ] +} +``` + +:::note + + Read more on the dedicated page: [Debugging](/book/debug). + +::: + +#### `masterchain` {#options-masterchain} + +`false{:json}` by default. + +If set to `true{:json}`, enables [masterchain](/book/masterchain) support. + +```json filename="tact.config.json" {8,14} +{ + "projects": [ + { + "name": "some_prefix", + "path": "./contract.tact", + "output": "./contract_output", + "options": { + "masterchain": true + } + }, + { + "name": "ContractUnderBlueprint", + "options": { + "masterchain": true + } + } + ] +} +``` + +:::note + + Read more on the dedicated page: [Masterchain](/book/masterchain). + +::: + +#### `external` {#options-external} + +`false{:json}` by default. + +If set to `true{:json}`, enables support of [external](/book/external) message receivers. + +```json filename="tact.config.json" {8,14} +{ + "projects": [ + { + "name": "some_prefix", + "path": "./contract.tact", + "output": "./contract_output", + "options": { + "external": true + } + }, + { + "name": "ContractUnderBlueprint", + "options": { + "external": true + } + } + ] +} +``` + +:::note + + Read more on the dedicated page: [External messages](/book/external). + +::: + +#### `ipfsAbiGetter` {#options-ipfsabigetter} + +`false{:json}` by default. + +If set to `true{:json}`, enables generation of a [getter](/book/contracts#getter-functions) with IPFS links describing the contract's ABI. + +```json filename="tact.config.json" {8,14} +{ + "projects": [ + { + "name": "some_prefix", + "path": "./contract.tact", + "output": "./contract_output", + "options": { + "ipfsAbiGetter": true + } + }, + { + "name": "ContractUnderBlueprint", + "options": { + "ipfsAbiGetter": true + } + } + ] +} +``` + +:::note + + Read more on the dedicated page: [OTP-003: Self-ABI reporting](/ref/evolution/otp-003). + +::: + +#### `interfacesGetter` {#options-interfacesgetter} + +`false{:json}` by default. + +If set to `true{:json}`, enables generation of a [getter](/book/contracts#getter-functions) with a list of interfaces provided by the contract. + +```json filename="tact.config.json" {8,14} +{ + "projects": [ + { + "name": "some_prefix", + "path": "./contract.tact", + "output": "./contract_output", + "options": { + "interfacesGetter": true + } + }, + { + "name": "ContractUnderBlueprint", + "options": { + "interfacesGetter": true + } + } + ] +} +``` + +:::note + + Read more: [Supported interfaces](/book/contracts#interfaces). + +::: + +#### `experimental` {#options-experimental} + +Experimental options that might be removed in the future. Use with caution! + +```json filename="tact.config.json" {8,14} +{ + "projects": [ + { + "name": "some_prefix", + "path": "./contract.tact", + "output": "./contract_output", + "options": { + "experimental": {} + } + }, + { + "name": "ContractUnderBlueprint", + "options": { + "experimental": {} + } + } + ] +} +``` + +##### `inline` {#experimental-inline} + +`false{:json}` by default. + +If set to `true{:json}`, enables inlining of all functions in contracts. This can reduce gas usage at the cost of bigger contracts. + +```json filename="tact.config.json" {9,17} +{ + "projects": [ + { + "name": "some_prefix", + "path": "./contract.tact", + "output": "./contract_output", + "options": { + "experimental": { + "inline": true + } + } + }, + { + "name": "ContractUnderBlueprint", + "options": { + "experimental": { + "inline": true + } + } + } + ] +} +``` + +### `mode` {#projects-mode} + +Compilation mode of the project. Valid values are: + +Value | Description +:------------------------------- | :---------- +`"full"{:json}` | (default) Runs the whole compilation pipeline and emits FunC code, BoC, and various utility files, including wrappers for TypeScript. +`"fullWithDecompilation"{:json}` | Runs the whole compilation pipeline like `"full"{:json}`, and also decompiles produced binary code in the BoC format. +`"funcOnly"{:json}` | Only outputs intermediate FunC code, preventing further compilation. +`"checkOnly"{:json}` | Only performs syntax and type checking, preventing further compilation. + +In [Blueprint][bp], `mode` is always set to `"full"{:json}` and cannot be overwritten. + +```json filename="tact.config.json" {7,13} +{ + "projects": [ + { + "name": "some_prefix", + "path": "./contract.tact", + "output": "./contract_output", + "mode": "full" + }, + { + "name": "func_only", + "path": "./contract.tact", + "output": "./contract_output", + "mode": "funcOnly" + } + ] +} +``` + +## Full example + +```json filename="tact.config.json" copy=false +{ + "$schema": "http://raw.githubusercontent.com/tact-lang/tact/main/schemas/configSchema.json", + "projects": [ + { + "name": "basic", + "path": "./basic.tact", + "output": "./basic_output", + "mode": "full" + }, + { + "name": "func_only", + "path": "./basic.tact", + "output": "./basic_output", + "mode": "funcOnly" + }, + { + "name": "debugPrefix", + "path": "./contracts/contract.tact", + "output": "./contracts/output", + "options": { + "debug": true + } + }, + { + "name": "ContractUnderBlueprint", + "options": { + "debug": false, + "masterchain": false, + "external": false, + "ipfsAbiGetter": true, + "interfacesGetter": true, + "experimental": { + "inline": false + } + } + } + ] +} +``` + +[bp]: https://github.com/ton-org/blueprint diff --git a/docs/src/content/docs/book/constants.mdx b/docs/src/content/docs/book/constants.mdx new file mode 100644 index 000000000..24ec3480b --- /dev/null +++ b/docs/src/content/docs/book/constants.mdx @@ -0,0 +1,71 @@ +--- +title: Constants +--- + +Constants in Tact could be a little bit more advanced than in popular languages: they could be virtual and abstract. Smart contracts often need to implement multiple traits and sometimes you need to configure some of them in compile time. Constructors in traits are prohibited due to their unpredicted behavior. So, we have to use constants and fields instead to pass values to them. It is the job of a main contract to implement values and constants for all traits. + +## Simple constant + +Let's start with a simple constant. It is a value that is defined in compile time and cannot be changed. You can define a constant on the top level or inside a contract/trait. Let's define a constant on top level: + +```tact +const MY_CONSTANT: Int = 42; +``` + +Similar for traits and contracts: + +```tact +trait MyTrait { + const MY_CONSTANT: Int = 42; +} + +contract MyContract { + const MY_CONSTANT: Int = 42; +} +``` + +## Virtual and abstract constants + +Virtual constants are the constants that could be defined in a trait but changed in a contract. It is useful when you need to configure some of the traits in compile time. Let's define a virtual constant and an abstract one: + +```tact +trait MyTrait { + virtual const MY_FEE: Int = ton("1.0"); +} + +trait MyAbstractTrait { + abstract const MY_DEV_FEE: Int; +} +``` + +Now you can overwrite defaults in the contract: + +```tact +contract MyContract with + MyTrait, + MyAbstractTrait, // trailing comma is allowed +{ + override const MY_FEE: Int = ton("0.5"); + override const MY_DEV_FEE: Int = ton("1000"); +} +``` + +This could be very useful to help a compiler to have some values in compile time, for example, you can enable and disable features without needing to change the code and not wasting gas. + +```tact +trait Treasure { + virtual const ENABLE_TIMELOCK: Bool = true; + + receive("Execute") { + if (self.ENABLE_TIMELOCK) { + // + // This branch would be removed in compile time if ENABLE_TIMELOCK is false + // + } + } +} + +contract MyContract with Treasure { + override const ENABLE_TIMELOCK: Bool = false; +} +``` diff --git a/docs/src/content/docs/book/contracts.mdx b/docs/src/content/docs/book/contracts.mdx new file mode 100644 index 000000000..d3dd21e3a --- /dev/null +++ b/docs/src/content/docs/book/contracts.mdx @@ -0,0 +1,353 @@ +--- +title: Contracts +--- + +Contracts in Tact are similar to classes in popular object-oriented languages, except that their instances are deployed on the blockchain and they can't be passed around like [Structs and Messages](/book/structs-and-messages). + +## Self-references {#self} + +Contracts and [traits][trait] have a built-in [identifier](/book/expressions#identifiers) `self{:tact}`, which is used for referring to their fields (persistent state [variables](#variables) and [constants](#variables)) and methods ([internal functions](#internal-functions)): + +```tact +contract Example { + // persistent state variables + foo: Int; + + init() { + self.foo = 42; // <- referencing variable foo through self. + } +} +``` + +## Structure + +Each contract can contain: + +* [Inherited traits](#traits) +* [Supported interfaces](#interfaces) +* [Persistent state variables](#variables) +* [Constructor function `init(){:tact}`](#init-function) +* [Contract constants](#constants) +* [Getter functions](#getter-functions) +* [Receiver functions](#receiver-functions) +* [Internal functions](#internal-functions) + +### Inherited traits, `with{:tact}` {#traits} + +Contracts can inherit all the declarations and definitions from [traits][trait] and override some of their default behaviours. In addition to that, every contract and trait implicitly inherits the special [`BaseTrait{:tact}` trait](/ref/core-base). + +To inherit a [trait][trait], specify its name after the keyword `with{:tact}` in contract's declaration. To inherit multiple traits at once, specify their names in a comma-separated list with an optional trailing comma. + +```tact /with/ +trait InheritMe {} +trait InheritMeToo {} + +// A contract inheriting a single trait +contract Single with InheritMe {} + +// A contract inheriting multiple traits +contract Plural with + InheritMe, + InheritMeToo, // trailing comma is allowed +{} +``` + +As [traits][trait] are not allowed to have [`init(){:tact}` function](#init-function), a contract inheriting a trait with any [persistent state variables](#variables) declared must initialize them by providing its own [`init(){:tact}` function](#init-function). + +```tact +trait Supe { omelander: Bool } + +contract Vot with Supe { + init() { + self.omelander = true; + } +} +``` + +If declared or defined in a trait, internal functions and constants can be marked as [virtual or abstract](/book/functions#virtual-and-abstract-functions) and overridden in contracts inheriting from the trait. + +### Supported interfaces, `@interface(…)` {#interfaces} + +It's hard to figure out what a contract does and what [receivers](#receiver-functions) and [getters](#getter-functions) it has without looking at its source code. Sometimes the source is unavailable or inaccessible, and all that's left is to try to disassemble the contract and introspect it that way, which is a very messy and error-prone approach with diminishing returns and no real reproducibility. + +In order to resolve this issue, an [OTP-001: Supported Interfaces](/ref/evolution/otp-001) was created. In accordance to it, Tact contracts [can report](/book/config#options-interfacesgetter) the list of supported interfaces as a return value of a special `supported_interfaces` [getter](#getter-functions). That getter is accessible off-chain using any TON Blockchain explorer — one just needs to specify `supported_interfaces` as a method to execute and get a list of hexadecimal values in return. + +These hexadecimal values are truncated to the first 128 bit of [SHA-256](https://en.wikipedia.org/wiki/SHA-2#Hash_standard) hashes of the original [`String{:tact}`][p] values of the supported interfaces. The first value in this list **must** be equal to $\mathrm{0x5cec3d5d2cae7b1e84ec39d64a851b66}$ in [hexadecimal notation](/book/integers#hexadecimal), which is the first half of the SHA-256 hash for `"org.ton.introspection.v0"{:tact}`. If the first value is wrong, you must stop trying to introspect the contract, as it doesn't conform to the [Supported Interfaces](/ref/evolution/otp-001) proposal. + +To declare support of a certain interface, add one or more `@interface("…"){:tact}` attributes right before contract and [trait][trait] declarations: + +```tact +@interface("His name is") +@interface("John") +contract SeeNah with Misc { + // ... +} + +@interface("name_of_your_org - miscellaneous") +trait Misc { + // ... +} +``` + +Tact has a small set of interfaces provided under specific conditions: + +* `"org.ton.abi.ipfs.v0"{:tact}`, in accordance to [OTP-003: Self-ABI Reporting](/ref/evolution/otp-003) — opt-in via [`ipfsAbiGetter`](/book/config#options-ipfsabigetter) config property +* `"org.ton.deploy.lazy.v0"{:tact}`, in accordance to [OTP-005: Argument-addressable contracts](/ref/evolution/otp-005) +* `"org.ton.debug.v0"{:tact}`, but only if [debug mode](/book/debug#debug-mode) is enabled +* `"org.ton.chain.any.v0"{:tact}` if [masterchain](/book/masterchain) support is enabled, and `"org.ton.chain.workchain.v0"{:tact}` otherwise + +Some [traits][trait] in [standard libraries](/ref/standard-libraries) define their interfaces too: + +* [`Ownable{:tact}`](/ref/stdlib-ownable#ownable) trait specifies `"org.ton.ownable"{:tact}` +* [`OwnableTransferable{:tact}`](/ref/stdlib-ownable#ownabletransferable) trait specifies `"org.ton.ownable.transferable.v2"{:tact}` +* [`Stoppable{:tact}`](/ref/stdlib-stoppable#stoppable) trait specifies `"org.ton.stoppable"{:tact}` +* [`Resumable{:tact}`](/ref/stdlib-stoppable#resumable) trait specifies `"org.ton.resumable"{:tact}` + +To enable `supported_interfaces` [getter](#getter-functions) generation and use `@interface(){:tact}` attribute in your Tact contracts, modify a [`tact.config.json`](/book/config) file in the root of your project (or create it if it didn't exist yet), and [set the `interfacesGetter` property to `true{:json}`](/book/config#options-interfacesgetter). + +If you're working on a [Blueprint][bp]-based project, you can enable `supported_interfaces` in the compilation configs of your contracts, which are located in a directory named `wrappers/`: + +```typescript title="wrappers/YourContractName.compile.ts" {7} +import { CompilerConfig } from '@ton/blueprint'; + +export const compile: CompilerConfig = { + lang: 'tact', + target: 'contracts/your_contract_name.tact', + options: { + interfacesGetter: true, // ← that's the stuff! + } +}; +``` + +In addition to that, [`tact.config.json`](/book/config) may still be used in [Blueprint][bp] projects. In such cases values specified in [`tact.config.json`](/book/config) act as default unless modified in the `wrappers/`. + +:::caution + + Be aware that adding an interface does not guarantee that the contract actually implements any particular functionality, or that it implements it in any particular way. It's just an off-chain, verifiable promise that a contract _might_ have some specific code in it. It's up to you to trust, but verify, such claims. + + In addition, there is no guarantee that there won't be name clashes between different interfaces, although they are unlikely because even the first 128 bits of SHA-256 provide sufficient [collision resistance](https://en.wikipedia.org/wiki/Collision_resistance). + +::: + +### Persistent state variables {#variables} + +Contracts can define state variables that persist between contract calls. Contracts in TON [pay rent](https://docs.ton.org/develop/smart-contracts/fees#storage-fee) in proportion to the amount of persistent space they consume, so [compact representations via serialization](/book/integers#serialization) are encouraged. + +```tact +contract Example { + // persistent state variables + val: Int; // Int + val32: Int as uint32; // Int serialized to an 32-bit unsigned + mapVal: map; // Int keys to Int values + optVal: Int?; // Int or null +} +``` + +State variables must have a default value or initialized in [`init(){:tact}`](#init-function) function, that runs on deployment of the contract. The only exception is persistent state variables of type [`map{:tact}`](/book/maps) since they are initialized empty by default. + +:::note + + Note, that Tact supports local, non-persistent-state variables too, see: [Variable declaration](/book/statements#let). + +::: + +### Contract constants {#constants} + +Unlike [variables](#variables), constants cannot change. Their values are calculated in _compile-time_ and cannot change during execution. + +There isn't much difference between constants defined outside of a contract (global constants) and inside the contract (contract constants). Those defined outside can be used by other contracts in your project. + +Constant initializations must be relatively simple and only rely on values known during compilation. If you add two numbers for example, the compiler will calculate the result during build and put the result in your compiled code. + +You can read constants both in [receivers](#receiver-functions) and in [getters](#getter-functions). + +Unlike [contract variables](#variables), **contract constants don't consume space in persistent state**. Their values are stored directly in the code [`Cell{:tact}`](/book/cells#cells) of the contract. + +```tact +// global constants are calculated in compile-time and cannot change +const GlobalConst1: Int = 1000 + ton("42") + pow(10, 9); + +contract Example { + // contract constants are also calculated in compile-time and cannot change + const ContractConst1: Int = 2000 + ton("43") + pow(10, 9); + + // contract constants can be an easy alternative to enums + const StateUnpaid: Int = 0; + const StatePaid: Int = 1; + const StateDelivered: Int = 2; + const StateDisputed: Int = 3; + + get fun sum(): Int { + // access constants from anywhere + return GlobalConst1 + self.ContractConst1 + self.StatePaid; + } +} +``` + +Read more about constants on their dedicated page: [Constants](/book/constants). + +### Constructor function `init()` {#init-function} + +On deployment of the contract, the constructor function `init(){:tact}` is run. + +If a contract has any [persistent state variables](#variables) without default values specified, it must initialize them in this function. + +```tact +contract Example { + // persistent state variables + var1: Int = 0; // initialized with default value 0 + var2: Int; // must be initialized in the init() function + + // constructor function + init() { + self.var2 = 42; + } +} +``` + +If a contract doesn't have any persistent state variables, or they all have their default value specified, it may omit the `init(){:tact}` function declaration altogether. That's because unless explicitly declared, the empty `init(){:tact}` function is present by default in all contracts. + +The following is an example of a valid empty contract: + +```tact +contract IamEmptyAndIKnowIt {} +``` + +For your convenience, parameter list of `init(){:tact}` can have a trailing comma: + +```tact +contract TheySeeMeTrailing { + init( + param1: Int, + param2: Int, // trailing comma is allowed + ) { + // ... + } +} +``` + +:::note + + To obtain initial state of the target contract in [internal functions](#internal-functions), [receivers](#receiver-functions) or [getters](#getter-functions) use [`initOf{:tact}`](/book/expressions#initof) expression. + +::: + +### Getter functions + +[Getter functions](/book/functions#getter-functions) are **not accessible from other contracts and exported only to off-chain world**. + +Additionally, **getters cannot modify the contract's state variables**, only read their values and use them in expressions. + +```tact +contract HelloWorld { + foo: Int; + + init() { + self.foo = 0; + } + + // getter function with return type Int + get fun foo(): Int { + return self.foo; // can't change self.foo here + } +} +``` + +Read more about them in their dedicated section: [Getter functions](/book/functions#getter-functions) + +### Receiver functions + +[Receiver functions](/book/functions#receiver-functions) in Tact can be one of the following three kinds: + +* [`receive(){:tact}`](/book/receive), which receive internal messages (from other contracts). +* [`bounced(){:tact}`](/book/bounced), which are called when outgoing message from this contract has bounced back. +* [`external(){:tact}`](/book/external), which don't have a sender and can be sent by anyone in the world. + +```tact +message CanBounce { + counter: Int; +} + +contract HelloWorld { + counter: Int; + + init() { + self.counter = 0; + } + + get fun counter(): Int { + return self.counter; + } + + // internal message receiver, which responds to a string message "increment" + receive("increment") { + self.counter += 1; + + // sending the message back to the sender + send(SendParameters{ + to: sender(), + value: 0, + mode: SendRemainingValue | SendIgnoreErrors, + body: CanBounce{counter: self.counter}.toCell(), + }); + } + + // bounced message receiver, which is called when the message bounces back to this contract + bounced(src: bounced) { + self.counter = 0; // reset the counter in case message bounced + } + + // external message receiver, which responds to off-chain message "hello, it's me" + external("hello, it's me") { + // can't be replied to as there's no sender! + self.counter = 0; + } +} +``` + +Naming a parameter of the receiver function with an underscore `_{:tact}` makes its value considered unused and discarded. This is useful when you don't need to inspect the message received and you only want it to convey a specific opcode: + +```tact +message(42) UniverseCalls {} + +contract Example { + receive(_: UniverseCalls) { + // Got a Message with opcode 42 + } +} +``` + +### Internal functions + +These functions behave similarly to private methods in popular object-oriented languages — they're internal to contracts and can be called by prefixing them with a special [identifier `self{:tact}`](#self). That's why internal functions can sometimes be referred to as "contract methods". + +Internal functions can access the contract's [persistent state variables](#variables) and [constants](#constants). + +They can only be called from [receivers](#receiver-functions), [getters](#getter-functions) and other internal functions, but not from other contracts or [`init(){:tact}`](#init-function). + +```tact +contract Functions { + val: Int = 0; + + // this contract method can only be called from within this contract and access its variables + fun onlyZeros() { + require(self.val == 0, "Only zeros are permitted!"); + } + + // receiver function, which calls the internal function onlyZeros + receive("only zeros") { + self.onlyZeros(); + } +} +``` + +:::note + + Note, that Tact supports other kinds of functions too, see: [Functions](/book/functions). + +::: + +[p]: /book/types#primitive-types +[trait]: /book/types#traits + +[bp]: https://github.com/ton-org/blueprint diff --git a/docs/src/content/docs/book/cs/from-func.mdx b/docs/src/content/docs/book/cs/from-func.mdx new file mode 100644 index 000000000..aff5a269a --- /dev/null +++ b/docs/src/content/docs/book/cs/from-func.mdx @@ -0,0 +1,11 @@ +--- +title: Coming from FunC +sidebar: + order: 1 +--- + +:::danger[Not implemented] + + This page awaits implementation in [#54](https://github.com/tact-lang/tact-docs/issues/54) + +::: diff --git a/docs/src/content/docs/book/cs/from-solidity.mdx b/docs/src/content/docs/book/cs/from-solidity.mdx new file mode 100644 index 000000000..30798de2a --- /dev/null +++ b/docs/src/content/docs/book/cs/from-solidity.mdx @@ -0,0 +1,11 @@ +--- +title: Coming from Solidity +sidebar: + order: 2 +--- + +:::danger[Not implemented] + + This page awaits implementation in [#67](https://github.com/tact-lang/tact-docs/issues/67) + +::: diff --git a/docs/src/content/docs/book/debug.mdx b/docs/src/content/docs/book/debug.mdx new file mode 100644 index 000000000..ec922de34 --- /dev/null +++ b/docs/src/content/docs/book/debug.mdx @@ -0,0 +1,728 @@ +--- +title: Debugging Tact contracts +--- + +import { LinkCard, CardGrid, Steps, Tabs, TabItem } from '@astrojs/starlight/components'; + +Without fail, the code we write as smart contract developers doesn’t always do what we expected it to do. Sometimes it does something completely different! When the unexpected happens, the next task is to figure out why. To do so, there are various ways to reveal problems or "bugs" in the code. Let's get to *debugging*! + + + + + + + + + + + + + + + + +## General approach {#approach} + +At the moment, Tact doesn't have a step-through debugger. Despite that, it's still possible to use the ["printf debugging"](https://en.wikipedia.org/wiki/Debugging#printf_debugging) approach. + +It involves actively placing [`dump(){:tact}`][dump] and [`dumpStack(){:tact}`](/ref/core-debug#dumpstack) function calls throughout your code and observing states of variables at a given point of time. Note, that those functions work only in a [debug mode](#debug-mode) and won't be executed otherwise. + +:::note + + See how to use [`dump(){:tact}`][dump] for debugging: [Debug with `dump(){:tact}`](#tests-dump). + +::: + +In addition to dumping values, it's often helpful to use assertive functions like [`require(){:tact}`](/ref/core-debug#require), [`nativeThrowIf(){:tact}`](/ref/core-debug#nativethrowif) and [`nativeThrowUnless(){:tact}`](/ref/core-debug#nativethrowunless). They help stating your assumptions clear, and are handy for setting up "trip wires" for catching issues in the future. + +And if you didn't find or cannot resolve the cause of your issues, try asking the community in Tact's [Telegram chat][tg] or, if your issue or question is generally related to TON more than it's related to Tact, hop into [TON Dev Telegram chat](https://t.me/tondev_eng). + +## Common debugging functions {#debug-functions} + +Tact provides a handful amount of various functions useful for debugging: [Core library → Debug](/ref/core-debug). + +## Enabling debug mode in compilation options {#debug-mode} + +In order to make certain functions like [`dump(){:tact}`][dump] or [`dumpStack(){:tact}`](/ref/core-debug#dumpstack) work, one needs to enable debug mode. + +The simplest and recommended approach is to modify a [`tact.config.json`](/book/config) file in the root of your project (or create it if it didn't exist yet), and [set the `debug` property to `true{:json}`](/book/config#options-debug). + +If you're working on a [Blueprint][bp]-based project, you can enable debug mode in the compilation configs of your contracts, which are located in a directory named `wrappers/`: + +```typescript title="wrappers/YourContractName.compile.ts" {7} +import { CompilerConfig } from '@ton/blueprint'; + +export const compile: CompilerConfig = { + lang: 'tact', + target: 'contracts/your_contract_name.tact', + options: { + debug: true, // ← that's the stuff! + } +}; +``` + +Note, that versions of [Blueprint][bp] starting with 0.20.0 automatically enable debug mode in `wrappers/` for new contracts. + +In addition to that, [`tact.config.json`](/book/config) may still be used in [Blueprint][bp] projects. In such cases values specified in [`tact.config.json`](/book/config) act as default unless modified in the `wrappers/`. + +:::note + + Read more about configuration and [`tact.config.json`](/book/config) file: [Configuration](/book/config).\ + See how to use [`dump(){:tact}`][dump] for debugging: [Debug with `dump(){:tact}`](#tests-dump). + +::: + +## Writing tests in Blueprint, with Sandbox and Jest {#tests} + +The [Blueprint][bp] is a popular development framework for writing, testing and deploying smart contracts on TON Blockchain. + +For testing smart contracts it uses the [Sandbox][sb], a local TON Blockchain emulator and [Jest][jest], a JavaScript testing framework. + +Whenever you create a new [Blueprint][bp] project or use `blueprint create` command inside the existing project, it creates a new contract alongside with a test suite file for it. + +Those files are placed in `tests/` folder and executed with [Jest][jest]. By default, all tests run, unless you specify specific group or test closure. For other options, refer to the brief documentation in the Jest CLI: `jest --help`. + +### Structure of test files {#tests-structure} + +Let's say that we have a contract named `Playground`, written in `contracts/playground.tact` file. If we've created that contract through [Blueprint][bp], then it also created a `tests/Playground.spec.ts` test suite file for us. + +The test file contains a single `describe(){:typescript}` [Jest][jest] function call, which denotes a test group. + +Inside that group, you'll have three variables, available in all tests within: + +* `blockchain` — local blockchain instance provided by [Sandbox][sb] +* `deployer` — a TypeScript wrapper used for deploying our `Playground` contract or any other we'd like to be deployed +* `playground` — a TypeScript wrapper for our `Playground` contract + +:::note + + It's a common mistake to update `.tact` code and run tests without making a build first. That's because tests in [Blueprint][bp] rely on TypeScript wrappers generated by a Tact compiler and work with the latest build made. + + That's why every time you make a change to your Tact code, make sure to also build it with `npx blueprint build` before you execute the test suite. For your convenience, you may unite builds and tests into a single command, as shown in the [experimental lab setup](#lab-4). + +::: + +Then, a `beforeEach(){:tact}` [Jest][jest] function is called — it specifies all the code to be executed before each of the subsequent test closures. + +:::note + + It is strongly advised not to modify the contents of `beforeEach(){:tact}`, unless you really need some specific behavior for each test closure or parameters of your [`init(){:tact}`](/book/contracts#init-function) function have changed. + +::: + +Finally, each test closure is described with a call to `it(){:tact}` [Jest][jest] function — that's where tests are actually written. + +A simplest example of the test closure can look like that: + +```typescript +it('should deploy', async () => { + // The check is done inside beforeEach, so this can be empty +}); +``` + +### Debug with `dump()` {#tests-dump} + +To see results of [`dump(){:tact}`][dump] function calls and use ["printf debugging"](#approach) approach, one has to: + +1. Put calls to [`dump(){:tact}`][dump] and other [common debugging functions](#debug-functions) in relevant places of the code. +2. Run [Jest][jest] tests, which would call target functions and send messages to target receivers. + +Assuming you've created a [new counter contract project](/#start), let's see how it works in practice. + +First, let's place a call to [`dump(){:tact}`][dump] in `contracts/simple_counter.tact`, which would output the `amount` passed in `msg{:tact}` [Struct][struct] to contract's debug console: + +```tact title="contracts/simple_counter.tact" {3} +// ... +receive(msg: Add) { + dump(msg.amount); + // ... +} +// ... +``` + +Next, let's comment out all existing `it(){:typescript}` test closures in `tests/SimpleCounter.spec.ts` file. And then add the following one: + +```typescript title="tests/SimpleCounter.spec.ts" +it('should dump', async () => { + await playground.send( + deployer.getSender(), + { value: toNano('0.5') }, + { $$type: 'Add', queryId: 1n, amount: 1n }, + ); +}); +``` + +It sends a message to our contract's `receive(msg: Add){:tact}` [receiver](/book/receive) without storing the [results of such send](#tests-send). + +Now, if we build our contract with `yarn build{:shell}` and run our test suite with `yarn test{:shell}`, we'll see the following in the test logs: + +```txt +console.log + #DEBUG#: [DEBUG] File contracts/simple_counter.tact:17:9 + #DEBUG#: 1 + + at SmartContract.runCommon (node_modules/@ton/sandbox/dist/blockchain/SmartContract.js:221:21) +``` + +Which is produced by of our [`dump(){:tact}`][dump] call above. + +:::note + + Read more about sending messages to contracts in tests: [Send messages to contracts](#tests-send). + +::: + +### State expectations with `expect()` {#tests-expect} + +The integral parts of writing tests is ensuring that your expectations match the observed reality. For that, [Jest][jest] provides a function `expect(){:tact}`, which is used as follows: + +1. First, an observed variable is provided. +2. Then, a specific method is called to check a certain property of that variable. + +Here's a more involved example, which uses `expect(){:tact}` function to check that counter contract actually properly increases the counter: + +```typescript +it('should increase counter', async () => { + const increaseTimes = 3; + for (let i = 0; i < increaseTimes; i++) { + console.log(`increase ${i + 1}/${increaseTimes}`); + + const increaser = await blockchain.treasury('increaser' + i); + + const counterBefore = await simpleCounter.getCounter(); + console.log('counter before increasing', counterBefore); + + const increaseBy = BigInt(Math.floor(Math.random() * 100)); + console.log('increasing by', increaseBy); + + const increaseResult = await simpleCounter.send( + increaser.getSender(), + { value: toNano('0.05') }, + { $$type: 'Add', queryId: 0n, amount: increaseBy } + ); + + expect(increaseResult.transactions).toHaveTransaction({ + from: increaser.address, + to: simpleCounter.address, + success: true, + }); + + const counterAfter = await simpleCounter.getCounter(); + console.log('counter after increasing', counterAfter); + + expect(counterAfter).toBe(counterBefore + increaseBy); + } +}); +``` + +:::note + + See more test examples in the [Sandbox][sb] documentation:\ + [Testing flow (FunC)](https://github.com/ton-org/sandbox/blob/main/docs/testing-key-points.md)\ + [Writing tests for Tact](https://github.com/ton-org/sandbox/blob/main/docs/tact-testing-examples.md) + +::: + +### Utility methods {#tests-jest-utils} + +Test files generated by [Blueprint][bp] import `@ton/test-utils` library, which provides access to a number of additional helper methods for the result type of `expect(){:typescript}` [Jest][jest] function. Note, that regular methods like `toEqual(){:typescript}` are still there and ready to be used. + +#### toHaveTransaction + +The method `expect(…).toHaveTransaction(){:typescript}` checks that the list of transactions has a transaction matching certain properties you specify: + +```typescript {2} +const res = await yourContractName.send(…); +expect(res.transactions).toHaveTransaction({ + // For example, let's check that a transaction to your contract was successful: + to: yourContractName.address, + success: true, +}); +``` + +To know the full list of such properties, look at auto-completion options provided by your editor or IDE. + +#### toEqualCell + +The method `expect(…).toEqualCell(){:typescript}` checks equality of two [cells](/book/cells#cells): + +```typescript {3} +expect(oneCell).toEqualCell(anotherCell); +``` + +#### toEqualSlice + +The method `expect(…).toEqualSlice(){:typescript}` checks equality of two [slices](/book/cells#slices): + +```typescript {3} +expect(oneSlice).toEqualSlice(anotherSlice); +``` + +#### toEqualAddress + +The method `expect(…).toEqualAddress(){:typescript}` checks equality of two [addresses](/book/types#primitive-types): + +```typescript {3} +expect(oneAddress).toEqualAddress(anotherAddress); +``` + +### Send messages to contracts {#tests-send} + +To send messages to contracts, use `.send(){:typescript}` method on their TypeScript wrappers like so: + +```typescript +// It accepts 3 arguments: +await yourContractName.send( + // 1. sender of the message + deployer.getSender(), // this is a default treasury, can be replaced + + // 2. value and (optional) bounce, which is true by default + { value: toNano('0.5'), bounce: false }, + + // 3. a message body, if any + 'Look at me!', +); +``` + +Message body can be a simple string, or an object specifying fields of the [Message](/book/structs-and-messages#messages) type: + +```typescript {4-8} +await yourContractName.send( + deployer.getSender(), + { value: toNano('0.5') }, + { + $$type: 'NameOfYourMessageType', + field1: 0n, // bigint zero + field2: 'yay', + }, +); +``` + +More often than not, it's important to store results of such sends, because they contain events occurred, transactions made and external messages sent: + +```typescript +const res = await yourContractName.send(…); +// res.events — array of events occurred +// res.externals — array of external-out messages +// res.transactions — array of transactions made +``` + +With that, we can easily filter or check certain transactions: + +```typescript +expect(res.transactions).toHaveTransaction(…); +``` + +### Observe the fees and values {#tests-fees} + +[Sandbox][sb] provides a helper function `printTransactionFees(){:typescript}`, which pretty-prints all the values and fees that went into transactions provided. It is quite handy for observing the flow of [nanoToncoins](/book/integers#nanotoncoin). + +To use it, modify imports from `@ton/sandbox` on top of the test file: + +```typescript +import { Blockchain, SandboxContract, TreasuryContract, printTransactionFees } from '@ton/sandbox'; +// ^^^^^^^^^^^^^^^^^^^^ +``` + +Then, provide an array of transactions as an argument, like so: + +```typescript +printTransactionFees(res.transactions); +``` + +To work with individual values of total fees or fees from compute and action [phases](https://docs.ton.org/learn/tvm-instructions/tvm-overview#transactions-and-phases), inspect each transaction individually: + +```typescript {11,17,21} +// Storing the transaction handled by the receiver in a separate constant +const receiverHandledTx = res.transactions[1]; +expect(receiverHandledTx.description.type).toEqual('generic'); + +// Needed to please TypeScript +if (receiverHandledTx.description.type !== 'generic') { + throw new Error('Generic transaction expected'); +} + +// Total fees +console.log('Total fees: ', receiverHandledTx.totalFees); + +// Compute fee +const computeFee = receiverHandledTx.description.computePhase.type === 'vm' + ? receiverHandledTx.description.computePhase.gasFees + : undefined; +console.log('Compute fee: ', computeFee); + +// Action fee +const actionFee = receiverHandledTx.description.actionPhase?.totalActionFees; +console.log('Action fee: ', actionFee); + +// Now we can do some involved checks, like limiting the fees to 1 Toncoin +expect( + (computeFee ?? 0n) + + (actionFee ?? 0n) +).toBeLessThanOrEqual(toNano('1')); +``` + +:::note + + [Sandbox][sb] has many more utility functions, which are often handy. For example, it provides `prettyLogTransaction(){:typescript}` and `prettyLogTransactions(){:typescript}`, which operate on a single or multiple transactions respectively and pretty-print flow of values between the addresses. + +::: + +### Transactions with intentional errors {#tests-errors} + +Sometimes it's useful to make negative tests, featuring intentional errors and throwing specific [exit codes](/book/exit-codes). + +Example of such [Jest][jest] test closure in [Blueprint][bp]: + +```typescript title="tests/YourTestFileHere.spec.ts" {9,15} +it('throws specific exit code', async () => { + // Send a specific message to our contract and store the results + const res = await your_contract_name.send( + deployer.getSender(), + { + value: toNano('0.5'), // value in nanoToncoins sent + bounce: true, // (default) bounceable message + }, + 'the message your receiver expects', // ← change it to yours + ); + + // Expect the transaction to our contract fail with a certain exit code + expect(res.transactions).toHaveTransaction({ + to: your_contract_name.address, + exitCode: 5, // ← change it to yours + }); +}); +``` + +Note, that to track down transactions with a certain exit code, you only need to specify `exitCode` field in object argument to the `toHaveTransaction(){:typescript}` method of `expect(){:typescript}`. + +However, it's useful to narrow the scope by specifying the recipient address `to`, such that Jest would look only at the transaction caused by our message to the contract. + +### Simulate passage of time {#tests-time} + +The Unix time in local blockchain instances provided by [Sandbox][bp] starts at the moment of the creation of those in `beforeEach(){:typescript}` block. + +```typescript {2} +beforeEach(async () => { + blockchain = await Blockchain.create(); // ← here + // ... +}); +``` + +Previously, we've been warned not to modify the `beforeEach(){:typescript}` block unless we really need to. And now, to override the time and time travel a little, we do. + +Let's add the following line by the end of it, setting `blockchain.now` explicitly to the time when deployment message was handled: +```typescript {3} +beforeEach(async () => { + // ... + blockchain.now = deployResult.transactions[1].now; +}); +``` + +Now, we can manipulate time in out test clauses. For example, let's make a transaction one minute after the deployment and another one after two: + +```typescript {2,4} +it('your test clause title', async () => { + blockchain.now += 60; // 60 seconds late + const res1 = await yourContractName.send(…); + blockchain.now += 60; // another 60 seconds late + const res2 = await yourContractName.send(…); +}); +``` + +## Logging via `emit` {#logging} + +A [global static function](/book/functions#global-static-functions) [`emit(){:tact}`](/ref/core-common#emit) sends a message to the outer world — it doesn't have a specific recipient. + +This function is very handy for logging and analyzing data off-chain — one just has to look at [external messages](/book/external) produced by the contract. + +### Logs in local Sandbox tests {#logging-local} + +When deploying in the [Sandbox][sb], you may call [`emit(){:tact}`](/ref/core-common#emit) from a [receiver function](/book/contracts#receiver-functions) and then observe the list of sent [external messages](/book/external): + +```typescript {9-10} +it('emits', async () => { + const res = await simpleCounter.send( + deployer.getSender(), + { value: toNano('0.05') }, + 'emit_receiver', // ← change to the message your receiver handles + ); + + console.log("Address of our contract: " + simpleCounter.address); + console.log(res.externals); // ← here one would see results of emit() calls, + // and all external messages in general +}); +``` + +### Logs of a deployed contract {#logging-deployed} + +Every transaction on TON Blockchain [contains `out_msgs`](https://docs.ton.org/develop/data-formats/transaction-layout#transaction) — a dictionary that holds the list of outgoing messages that were created while executing the transaction. + +To see logs from [`emit(){:tact}`](/ref/core-common#emit) in that dictionary, look for external messages without a recipient. In various TON Blockchain explorers, such transactions will be marked as `external-out` with destination specified as `-` or `empty`. + +Note, that some explorers deserialize the message body sent for you, while others don't. However, you can always [parse it yourself](#logging-parsing) locally. + +### Parsing body of the emitted message {#logging-parsing} + +Consider the following example: + +```tact +// We have a Struct +struct Ballroom { + meme: Bool; + in: Int; + theory: String; +} + +// And a simple contract, +contract Bonanza { + // which can receive a String message, + receive("time to emit") { + // emit a String + emit("But to the Supes? Absolutely diabolical.".asComment()); + + // and a Struct + emit(Ballroom{meme: true, in: 42, theory: "Duh"}.toCell()); + } +} +``` + +Now, let's make a simple [test clause](#tests-structure) for the `Bonanza` contract: + +```typescript /bonanza/ +it('emits', async () => { + const res = await bonanza.send( + deployer.getSender(), + { value: toNano('0.05') }, + 'time to emit', + ); +}); +``` + +There, the `res` object would contain the list of sent [external messages](/book/external) as its `externals` field. Let's access it to parse the first message sent via a call to [`emit(){:tact}`](/ref/core-common#emit) in Tact code (or _emitted_ for short): + +```typescript /body/ +it('emits', async () => { + // ... prior code ... + + // We'll need only the body of the observed message: + const firstMsgBody = res.externals[0].body; + + // Now, let's parse it, knowing that it's a text message. + // NOTE: In a real-world scenario, + // you'd want to check that first or wrap this in a try...catch + const firstMsgText = firstMsgBody.asSlice().loadStringTail(); + + // "But to the Supes? Absolutely diabolical." + console.log(firstMsgText); +}); +``` + +To parse the second emitted message, we could manually use a bunch of `.loadSomething(){:typescript}` functions, but that's way too brittle — if the fields of the `Ballroom{:tact}` [Struct][struct] even change, you'd need to start all over. That could really backfire when you have a lot of tests written in that manner. + +Fortunately, Tact compiler auto-generates TypeScript bindings (or wrappers) for the contracts, and it's really easy to re-use them in your test suite. Not only they have a wrapper of the contract you're testing, but they also export a bunch of helper functions to store or load [Structs][struct] and [Messages][message] defined in the contract. The latter will be named just like the [Structs][struct] and [Messages][message] are, but with the `load` prefix in front. + +For example, in our case we'll need a function called `loadBallroom(){:typescript}`, for parsing a [`Slice{:tact}`][slice] into the `Ballroom{:tact}` [Struct][struct] in TypeScript. To import it, either type the name and let your IDE suggest auto-importing it for you, or take a look at the top of your test suite file — there should be a similar line: + +```typescript +import { Bonanza } from '../wrappers/Bonanza'; +// ^ here you could import loadBallroom +``` + +With that, let's parse the second emitted message: + +```typescript +it('emits', async () => { + // ... prior code ... + + // We'll need only the body of the observed message: + const secondMsgBody = res.externals[1].body; + + // Now, let's parse it, knowing that it's the Ballroom Struct. + // NOTE: In a real-world scenario, + // you'd want to check that first or wrap this in a try...catch + const secondMsgStruct = loadBallroom(secondMsgBody.asSlice()); + + // { '$$type': 'Ballroom', meme: true, in: 42n, theory: 'Duh' } + console.log(secondMsgStruct); +}); +``` + +Mind you, that it's also possible to parse emitted messages of deployed contracts even outside of our test suite. You would just need to obtain the emitted message bodies and then use the auto-generated TypeScript bindings of Tact alongside the `@ton/core` library just like we did in those examples above. + +## Handling bounced messages {#bounced} + +When [sent](/book/send) with `bounce: true{:tact}`, messages can bounce back in case of errors. Make sure to write relevant [`bounced(){:tact}`](/book/bounced) message [receivers](/book/contracts#receiver-functions) and handle bounced messages gracefully: + +```tact +bounced(msg: YourMessage) { + // ...alright squad, let's bounce!... +} +``` + +Keep in mind that bounced messages in TON have only $224$ usable data bits in their message body and don't have any references, so one cannot recover much data from it. However, you still get to see whether the message has bounced or not, allowing you to create more robust contracts. + +Read more about bounced messages and receivers: [Bounced messages](/book/bounced). + +## Experimental lab setup {#lab} + +If you're overwhelmed by the testing setup of [Blueprint][bp] or just want to test some things quickly, worry not — there is a way to set up a simple playground as an experimental lab to test your ideas and hypotheses. + + + +1. #### Create a new Blueprint project {#lab-1} + + That will prevent pollution of your existing one with arbitrary code and tests. + + The new project can be named anything, but I'll name it `Playground` to convey the right intent. + + To create it, run the following command: + + + + ```shell + # recommended + yarn create ton tact-playground --type tact-empty --contractName Playground + ``` + + + ```shell + npm create ton@latest -- tact-playground --type tact-empty --contractName Playground + ``` + + + ```shell + pnpm create ton@latest tact-playground --type tact-empty --contractName Playground + ``` + + + ```shell + bun create ton@latest tact-playground --type tact-empty --contractName Playground + ``` + + + + Versions of [Blueprint][bp] starting with 0.20.0 automatically enable debug mode in `wrappers/` for new contracts, so we only have to adjust the testing suite and prepare our `Playground` contract for testing. + +2. #### Update the test suite {#lab-2} + + Move into the newly created `tact-playground/` project and in the `tests/Playground.spec.ts`, change the `"should deploy"{:tact}` test closure to the following: + + ```typescript title="tests/Playground.spec.ts" + it('plays', async () => { + const res = await playground.send( + deployer.getSender(), + { value: toNano('0.5') }, // ← here you may increase the value in nanoToncoins sent + 'plays', + ); + + console.log("Address of our contract: " + playground.address); + console.log(res.externals); // ← here one would see results of emit() calls + }); + ``` + +3. #### Modify the contract {#lab-3} + + Replace the code in `contracts/playground.tact` with the following: + + ```tact title="contracts/playground.tact" {4-6} + import "@stdlib/deploy"; + + contract Playground with Deployable { + receive("plays") { + // NOTE: write your test logic here! + } + } + ``` + + The basic idea of this setup is to place the code you want to test into the [receiver function](/book/contracts#receiver-functions) responding to the [string](/book/types#primitive-types) message `"plays"{:tact}`. + + Note, that you can still write any valid Tact code outside of that [receiver](/book/contracts#receiver-functions). But in order to test it you'll need to write related test logic inside of it. + +4. #### Let's test! {#lab-4} + + With that, our experimental lab setup is complete. To execute that single test we've prepared for our `Playground` contract, run the following: + + ```shell + yarn test -t plays + ``` + + From now on, to test something you only need to modify the contents of the tested [receiver function](/book/contracts#receiver-functions) of your Tact contract file and re-run the command above. Rinse and repeat that process until you've tested what you wanted to test. + + For simplicity and cleaner output's sake, you may add a new field to `scripts` in your `package.json`, such that you'll only need to run `yarn lab{:shell}` to build and test in one. + + On Linux or macOS, it would look like: + + ```json filename="package.json" {3} + { + "scripts": { + "lab": "blueprint build 1>/dev/null && yarn test -t plays" + } + } + ``` + + And here's how it may look on Windows: + + ```json filename="package.json" {3-4} + { + "scripts": { + "build": "blueprint build | out-null", + "lab": "yarn build && yarn test -t plays" + } + } + ``` + + To run: + + ```shell + yarn lab + ``` + + + +[dump]: /ref/core-debug#dump +[struct]: /book/structs-and-messages#structs +[message]: /book/structs-and-messages#messages +[cell]: /book/cells#cells +[slice]: /book/cells#slices + +[tg]: https://t.me/tactlang +[bp]: https://github.com/ton-org/blueprint +[sb]: https://github.com/ton-org/sandbox +[jest]: https://jestjs.io diff --git a/docs/src/content/docs/book/deploy.mdx b/docs/src/content/docs/book/deploy.mdx new file mode 100644 index 000000000..9702a5a54 --- /dev/null +++ b/docs/src/content/docs/book/deploy.mdx @@ -0,0 +1,52 @@ +--- +title: Deployment +--- + +Tact Deployer is a small library that integrates with [TON Verifier](https://verifier.ton.org) that allows you to deploy your contracts safely using your favorite wallet without needing to manage keys or deploy contracts manually. Tact Deployer also automatically verifies your contract's source code and you can be sure that your compiler is not compromised. + +## Requirements + +Your contract MUST have the `Deployer` trait from the `@stdlib/deploy` package to be able to use Tact Deployer. + +## Installation + +To add Tact Deployer to your project, just use `yarn`: + +```bash +yarn add @tact-lang/deployer +``` + +## How to use + +When you build your smart contracts using Tact, it produces a package (*.pkg) file that has all the required information about the built smart contract. To deploy your smart contract, you need to create a deployer instance, pass your package file to it and provide initial data for your contract. + +```typescript +import * as fs from 'fs'; +import * as path from 'path'; +import { Address, contractAddress } from "ton"; +import { SampleTactContract } from "./output/sample_SampleTactContract"; +import { prepareTactDeployment } from "@tact-lang/deployer"; + +// Parameters +let testnet = true; // Flag for testnet or mainnet +let packageName = 'sample_SampleTactContract.pkg'; // Name of your package to deploy +let outputPath = path.resolve(__dirname, 'output'); // Path to output directory +let owner = Address.parse(''); // Our sample contract has an owner +let init = await SampleTactContract.init(owner); // Create initial data for our contract + +// Calculations +let address = contractAddress(0, init); // Calculate contract address. MUST match with the address in the verifier +let data = init.data.toBoc(); // Create init data +let pkg = fs.readFileSync( // Read package file + path.resolve(outputPath, packageName) +); + +// Prepare deploy +let link = await prepareTactDeployment({ pkg, data, testnet }); + +// Present a deployment link and contract address +console.log('Address: ' + address.toString({ testOnly: testnet })); +console.log('Deploy link: ' + link); +``` + +After following this link you will be able to deploy and verify your smart contract. diff --git a/docs/src/content/docs/book/exit-codes.mdx b/docs/src/content/docs/book/exit-codes.mdx new file mode 100644 index 000000000..42a46e20c --- /dev/null +++ b/docs/src/content/docs/book/exit-codes.mdx @@ -0,0 +1,324 @@ +--- +title: Exit Codes +--- + +:::caution + THis page is under re-construction as per [#106](https://github.com/tact-lang/tact-docs/issues/106). All anchor links (`#`) may change in the future! +::: + +An exit code is a $16$-bit unsigned integer which ranges between $0$ to $65535$ (or $2_{16} - 1$). + +Codes from $0$ to $127$ are allocated for FunC (TVM), $128$ to $255$ for Tact. The range from $256$ to $65535$ is free for developer-defined exit codes. + +List of pre-allocated exit codes: + +Exit Code | phase | Description +:--------- | :----------------- | -------------------------------------------------------------------------------------------------------------------------- +$0$ | [Compute phase][c] | Standard successful execution exit code +$2$ | [Compute phase][c] | Stack underflow. Last op-code consumed more elements than there are on the stacks +$3$ | [Compute phase][c] | Stack overflow. More values have been stored on a stack than allowed by this version of TVM +$4$ | [Compute phase][c] | Integer overflow. Integer does not fit into −2256 ≤ x < 2256 or a division by zero has occurred +$5$ | [Compute phase][c] | Integer out of expected range +$6$ | [Compute phase][c] | Invalid opcode. Instruction is unknown in the current TVM version +$7$ | [Compute phase][c] | Type check error. An argument to a primitive is of an incorrect value type +$8$ | [Compute phase][c] | Cell overflow. Writing to builder is not possible since after operation there would be more than 1023 bits or 4 references +$9$ | [Compute phase][c] | Cell underflow. Read from slice primitive tried to read more bits or references than there are +$10$ | [Compute phase][c] | Dictionary error. Error during manipulation with dictionary (hashmaps) +$13$ | [Compute phase][c] | Out of gas error. Thrown by TVM when the remaining gas becomes negative +$-14$ | [Compute phase][c] | It means out of gas error, same as $13$. Negative, because it cannot be faked +$32$ | [Action phase][a] | Action list is invalid. Set during action phase if c5 register after execution contains unparsable object +$34$ | [Action phase][a] | Action is invalid or not supported. Set during action phase if current action cannot be applied +$37$ | [Action phase][a] | Not enough TON. Message sends too much TON (or there is not enough TON after deducting fees) +$38$ | [Action phase][a] | Not enough extra-currencies +$128$ | Tact (Compiler) | Null reference exception — compiler expects an integer or cell but a null value has been passed +$129$ | Tact (Compiler) | Invalid serialization prefix — if there is any inconsistency with the previous op-code check, this exit code will be thrown +$130$ | Tact (Compiler) | Invalid incoming message — no suitable operation is found +$131$ | Tact (Compiler) | Constraints error +$132$ | Tact (Compiler) | Access denied — someone other than the owner sent a message to the contract +$133$ | Tact (Compiler) | Contract stopped — a message has been sent to a stopped contract +$134$ | Tact (Compiler) | Invalid argument — invalid Base64 string +$135$ | Tact (Compiler) | Code of a contract was not found — false flag for a dictionary call +$136$ | Tact (Compiler) | Invalid Address — Non $267$-bit Address or invalid chain id (other than 0 or -1) +$137$ | Tact (Compiler) | Masterchain support is not enabled for this contract + +[c]: https://docs.ton.org/learn/tvm-instructions/tvm-overview#compute-phase +[a]: https://docs.ton.org/learn/tvm-instructions/tvm-overview#transactions-and-phases + +Q: **Where to observe the list of all auto-generated exit codes in your project?**\ +A: The Tact Compiler collects all exit codes at the end of a *.md file and you can track them in the directory along +the path "./ProjectFolder/build/ProjectName/tact_ProjectName.md" + +Q: **How to observe a thrown exit code?**\ +A: In Tact, it's not wise to print the transactions to see the results because they are not easy to read. If you want to see the exit code of a transaction, +use the below template in your Typescript local tests: + +```typescript +const sender = await blockchain.treasury('sender'); +const result = await contractName.send(sender.getSender(), { value: toNano('0.05'), }, { transactionData }); + +expect(result.transactions).toHaveTransaction( + { from: sender.address, to: contractName.address, exitCode: YOUR_DESIRED_EXIT_CODE } +); +``` +* First line defines the sender. +* Second line sends the transaction. +* In the third line, you check if the result has a transaction from sender to your contract with your desired exit code. + +## Compute phase + +### $0$: Successful execution {#0} + +This exit code means that the Compute phase of the transaction was completed successfully. + +### $4$: Integer overflow {#4} + +In TVM, integer can be in the range -2256 < x < 2256. +If the value during the calculation went beyond this range, then 4 exit code is thrown. + +Example: + +```tact +self.id = 1; // force not to ignore it by using storage variables +repeat(256) { + self.id = 2 * self.id; +} +``` + +### $5$: Integer out of expected range {#5} + +If the integer value went beyond the expected range, then 5 exit code is thrown. +For example, if a negative value was used in the .store_uint() function. In Tact, there are some other new situations such as:\ +1- As you know, you can define more limited integers in Tact (integers with less than 257 bits). +If you try to store a number in this kind of integers and the number doesn't fit to this limited range, you will face this exit code.\ +2- according to ```storeUint(self: Builder, value: Int, bits: Int)``` function, it's not possible to use ```storeUint(0, 257)``` because ```0 ≤ bits ≤ 256```. + +Example: + +```tact +// option 1 -> id: Int as uint32 +self.id = 1; // force not to ignore it by using storage variables +repeat(32) { + self.id = 2 * self.id; +} + +// option 2 -> according to storeUint(self: Builder, value: Int, bits: Int) function, it's not possible to use storeUint(0, 1024) because 0 ≤ bits ≤ 256 +let s: Slice = beginCell().storeUint(0, 257).asSlice(); +``` + +### $8$: Cell overflow {#8} +A cell has the capacity to store 1023 bits of data and 4 references to other cells. +If you try to write more than 1023 bits or more than 4 references, 8 exit code is thrown. + +Example: + +```tact +// according to storeUint(self: Builder, value: Int, bits: Int) function, it's not possible to use storeUint(0, 1024) because 0 ≤ bits ≤ 256 +let s: Slice = beginCell().storeUint(0, 256).storeUint(0, 256).storeUint(0, 256).storeUint(0, 256).asSlice(); +``` + +### $9$: Cell underflow {#9} + +If you try to read more data from a slice than it contains, then 9 exit code is thrown. + +Example: + +```tact +let s: Slice = emptySlice(); +self.id = s.loadUint(1); // force not to ignore it by using storage variables +``` + +### $13$: Out of gas error {#13} + +If there isn't enough TON to handle compute phase, this error is thrown. + +During processing, the NOT operation is applied to this value, which changes this value to -14. This is done so that this exit code cannot be faked using the throw function, since all such functions accept only positive values for the exit code as it was discussed previously. + +Example: + +```tact +repeat(10000) { + self.id += 1; +} +``` + +## Action phase + +### $34$: Action is invalid or not supported {#34} + +This exit code is responsible for most of the errors when working with actions: invalid message, incorrect action, and so on. + +Example: + +```tact +nativeSendMessage(emptyCell(), 0); +``` + +### $37$: Not enough TON {#37} + +It means that there isn't enough TON to send the specified amount of it. + +Example: + +```tact +send(SendParameters{to: context().sender, value: ton("10")}); +``` + +## Tact (Compiler) + +### 128: Null reference exception {#128} + +If there's a non-null assertion, such as the [`!!{:tact}`](/book/operators#unary-non-null-assert) operator, and the checked value is [`null{:tact}`](/book/optionals), an error with exit code $128$ is thrown: `Null reference exception`. + +```tact +let gotcha: String? = null; + +try { + // Asserting that the value isn't null, which isn't the case! + dump(gotcha!!); +} catch (exitCode) { + exitCode; // 128 +} +``` + +### $130$: Invalid incoming message {#130} + +When you send a message to a contract, the first 32 bits of message body is the op code. It determines the operation that must be done. +In FunC, if no op code is found, 0xffff will be thrown. In Tact, 130 exit code will be thrown. + +Example: + +1. First, define an empty contract like below: + +```tact +contract Fireworks {} +``` + +2. Then, send a message to this contract. Because no suitable operation is found, you will get this exit code. + +### $132$: Access denied {#132} + +First, you should import and inherit from Ownable Trait. After it, your contract will have an owner. +You can ask for a check by calling ```self.requireOwner();``` in your functions. It will ensure that only the owner can send message to your contract. + +Example: + +```tact +import "@stdlib/deploy"; +import "@stdlib/ownable"; + +message FakeLaunch { + +} + +contract Fireworks with + Deployable, + Ownable, +{ + owner: Address; + + init(){ + self.owner = sender(); + } + + receive(msg: FakeLaunch){ + self.requireOwner(); + } +} + +fun requireOwner() { + nativeThrowUnless(132, sender() == self.owner); +} +``` + +### $133$: Contract stopped {#133} + +The stoppable trait allows to stop the contract. +If you send a message to a stopped contract, and the contract asks for a check by running ```self.requireNotStopped();```, this exit code will be thrown. +In the current version of Tact, 40368 exit code will be thrown instead of 133. + +Example: + +```tact +import "@stdlib/deploy"; +import "@stdlib/ownable"; +import "@stdlib/stoppable"; + +message FakeLaunch {} + +contract Fireworks with + Deployable, + Ownable, + Stoppable, +{ + owner: Address; + stopped: Bool; + + init() { + self.owner = sender(); + self.stopped = false; + } + + receive(msg: FakeLaunch) { + self.stopped = true; + self.requireNotStopped(); + } +} + +fun requireNotStopped() { + require(!self.stopped, "Contract stopped"); +} +``` + +### $134$: Invalid argument {#134} + +This will be thrown by the below FunC function(in the last part of a bunch of if conditions). This function reads something from Base64. + +If the input characters don't fit into base64 chars, you will encounter this exit code. + +Example: + +```tact +let code: Slice = beginCell().storeUint(0, 8).asSlice().fromBase64(); +// 0 is not a valid ASCII code so it cannot be converted to Base64 +``` + +### $135$: Code of a contract was not found {#135} + +It will check the return flag of a search on the dictionary keys. + +Example: + +```tact +// copy & paste the below line in wrapper file(../build/ContractName/tact_ContractName.ts) instead of the second line of ContractName_init() function - this is a dictionary containing another smart contract code which leads to 135 exit code +// const __system = Cell.fromBase64('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'); +let ctx: Context = context(); +let fireworks_init: StateInit = initOf Fireworks(0); +``` + +### $136$: Invalid address {#136} + +In TON, all addresses are 267 bits. If you violate this rule, you will face this exit code. + +Currently, TON only supports two chain id. 0 for basechain and -1 for masterchain. If you address isn't from basechain, 136 exit code will be thrown. + +Example: + +```tact +// fun newAddress(chain: Int, hash: Int): Address; +// creates a new address from chain and hash values. +let zeroAddress: Address = newAddress(1, 0); // invalid chain zero address +``` + +### $137$: Masterchain support is not enabled for this contract {#137} + +Currently, TON only supports two chain id. 0 for basechain and -1 for masterchain. + +Tact only supports basechain and if you address is from masterchain, 137 exit code will be thrown. + +Example: + +```tact +// fun newAddress(chain: Int, hash: Int): Address; +// creates a new address from chain and hash values. +let zeroAddress: Address = newAddress(-1, 0); // masterchain zero address +``` diff --git a/docs/src/content/docs/book/expressions.mdx b/docs/src/content/docs/book/expressions.mdx new file mode 100644 index 000000000..9ff8f5012 --- /dev/null +++ b/docs/src/content/docs/book/expressions.mdx @@ -0,0 +1,256 @@ +--- +title: Expressions +--- + +Every operator in Tact forms an expression, but there's much more to uncover as Tact offers a wide range of expressive options to choose from. + +## Literals + +Literals represent values in Tact. These are fixed values—not variables—that you _literally_ provide in your code. All literals in Tact are expressions themselves. + +You can also call [extension functions](/book/functions#extension-function) defined on certain [primitive types][p] corresponding to literals right on the literal values: + +```tact +// Calling toString() defined for Int on a integer literal: +42.toString(); + +// Calling asComment() defined for String on a string literal: +"Tact is awesome!".asComment(); +``` + +### Integer literals + +Integer literals can be written in [decimal](/book/integers#decimal) (base $10$), [hexadecimal](/book/integers#hexadecimal) (base $16$), [octal](/book/integers#octal) (base $8$) and [binary](/book/integers#binary) (base $2$) notations: + +* A [_decimal_ integer](/book/integers#decimal) literal is a sequence of digits ($\mathrm{0 - 9}$). + +* A leading $\mathrm{0x}$ (or $\mathrm{0X}$) indicates a [hexadecimal integer](/book/integers#hexadecimal) literal. They can include digits ($\mathrm{0 - 9}$) and the letters $\mathrm{a - f}$ and $\mathrm{A - F}$. Note, that the case of a character does not change its value. Therefore: $\mathrm{0xa}$ = $\mathrm{0xA}$ = $10$ and $\mathrm{0xf}$ = $\mathrm{0xF}$ = $15$. + +* A leading $\mathrm{0o}$ (or $\mathrm{0O}$) indicates a [octal integer](/book/integers#octal) literals. They can include only the digits $\mathrm{0 - 7}$. + +* A leading $\mathrm{0b}$ (or $\mathrm{0B}$) indicates a [binary integer](/book/integers#binary) literal. THey can only include the digits $0$ and $1$. + +:::caution + Be wary that in Tact integer literals with a leading $0$ are still considered decimals, unlike in JavaScript/TypeScript where leading $0$ indicates an octal! +::: + +Some examples of integer literals: + +```tact +// decimal, base 10: +0, 42, 1_000, 020 + +// hexadecimal, base 16: +0xABC, 0xF, 0x0011 + +// octal, base 8: +0o777, 0o001 + +// binary, base 2: +0b01111001_01101111_01110101_00100000_01100001_01110010_01100101_00100000_01100001_01110111_01100101_01110011_01101111_01101101_01100101 +``` + +Read more about integers and [`Int{:tact}`](/book/integers) type on the dedicated page: [Integers](/book/integers). + +### Boolean literals + +The [`Bool{:tact}`](/book/types#booleans) type has only two literal values: `true{:tact}` and `false{:tact}`. + +```tact +true == true; +true != false; +``` + +Read more about booleans and [`Bool{:tact}`](/book/types#booleans) type in the dedicated chapter: [Booleans](/book/types#booleans). + +### String literals + +A string literal is zero or more characters enclosed in double (`"`) quotation marks. All string literals are objects of [`String{:tact}`][p] type. + +```tact +"foo"; +"1234"; +``` + +Tact strings support a range of [escape sequences](https://en.wikipedia.org/wiki/Escape_sequence) starting with a backslash `\\` character: + +* `\\{:tact}` — literal backslash +* `\"{:tact}` — double quote +* `\n{:tact}` — newline +* `\r{:tact}` — carriage return +* `\t{:tact}` — tab +* `\v{:tact}` — vertical tab +* `\b{:tact}` — backspace +* `\f{:tact}` — form feed +* `\x00{:tact}` through `\xFF{:tact}` — [code point](https://en.wikipedia.org/wiki/Code_point), must be exactly two hex digits long +* `\u0000{:tact}` through `\uFFFF{:tact}` — [Unicode code point][unicode], must be exactly four hex digits long +* `\u{0}{:tact}` through `\u{FFFFFF}{:tact}` — [Unicode code point][unicode], can be from $1$ to $6$ hex digits long + +[unicode]: https://en.wikipedia.org/wiki/Unicode#Codespace_and_code_points + +```tact +// \\ +"escape \\ if \\ you \\ can \\"; + +// \" +"this \"literally\" works"; + +// \n +"line \n another line"; + +// \r +"Shutters \r Like \r This \r One"; + +// \t +"spacing \t granted!"; + +// \v +"those \v words \v are \v aligned"; + +// \b +"rm\b\bcreate!"; + +// \f +"form \f feed"; + +// \x00 - \xFF +"this \x22literally\x22 works"; // \x22 represents a double quote + +// \u0000 - \uFFFF +"danger, \u26A1 high voltage \u26A1"; // \u26A1 represents the ⚡ emoji + +// \u{0} - \u{FFFFFF} +"\u{1F602} LOL \u{1F602}"; // \u{1F602} represents the 😂 emoji +``` + +:::note + + Read more about strings and [`String{:tact}`][p] type:\ + [Primitive types in the Book][p]\ + [Strings and StringBuilders in the Reference](/ref/core-strings) + +::: + +### `null` literal + +The `null{:tact}` value is written with a `null{:tact}` literal. It's **not** an [identifier](#identifiers) and doesn't refer to any object. It's also **not** an instance of a [primitive type][p]. Instead, `null{:tact}` represents a lack of identification and the intentional absence of any value. + +```tact +let var: Int? = null; // variable, which can hold null value +var = 42; +if (var != null) { + var!! + var!!; +} +``` + +Read more about working with `null{:tact}` on the dedicated page: [Optionals](/book/optionals). + +## Identifiers + +An identifier is a sequence of characters in the code that _identifies_ a [variable](/book/statements#let), [constant](/book/constants), [map](/book/maps) and a [function](/book/functions), as well as a [Struct][s], [Message][m], [contract](/book/contracts), [trait](/book/types#traits), or their fields and methods. Identifiers are case-sensitive and not quoted. + +In Tact, identifiers can contain latin lowercase letters (`a-z`), latin uppercase letters (`A-Z`), underscores (`_`) and digits ($\mathrm{0 - 9}$), but may not start with a digit. An identifier differs from a [string](#string-literals) in that a string is data, while an identifier is part of the code. + +Note, that when identifiers for [primitive types][p] start with an uppercase letter. Used-defined [composite types](/book/types#composite-types), such as [Structs][s] and [Messages][m] also must be capitalized. + +## Instantiation + +You can create instances of the following types: + +* [Structs][s] +* [Messages][m] + +```tact +struct StExample { + fieldInit: Int = 1; + fieldUninit: Int; +} + +fun example() { + // Instance with default value of fieldInit + StExample{ fieldUninit: 2 }; + + // Instance with both fields set + StExample{ + fieldInit: 0, + fieldUninit: 2, // trailing comma is allowed + }; +} +``` + +## Field access + +You can directly access fields of the following types: + +* [Structs][s] +* [Messages][m] + +```tact +struct StExample { + fieldInit: Int = 1; + fieldUninit: Int; +} + +fun example(): Int { + let struct: StExample = StExample{ fieldUninit: 2 }; // instantiation + + struct.fieldInit; // access a field + return struct.fieldUninit; // return field value from the function +} +``` + +## Extension function call + +[Extension functions](/book/functions#extension-function) are defined only on specific types. They can be called similar to method calls in many other languages: + +```tact +42.toString(); // toString() is a stdlib function that is defined on Int type +``` + +## Static function call + +Anywhere in the function body, a global [static function](/book/functions#global-static-functions) or an internal function of a [contract](/book/contracts) can be called: + +```tact +contract ExampleContract { + receive() { + now(); // now() is a static function of stdlib + let expiration: Int = now() + 1000; // operation and variable declaration + expiration = self.answerQuestion(); // internal function + } + fun answerQuestion(): Int { + return 42; + } +} +``` + +## `initOf` + +Expression `initOf{:tact}` computes initial state (`StateInit{:tact}`) of a [contract](/book/contracts): + +```tact +// argument values for the init() function of the contract +// ↓ ↓ +initOf ExampleContract(42, 100); // returns a Struct StateInit{} +// --------------- +// ↑ +// name of the contract +// ↓ +// --------------- +initOf ExampleContract( + 42, // first argument + 100, // second argument, trailing comma is allowed +); +``` + +Where `StateInit{:tact}` is a built-in [Struct][s], that consists of: + +Field | Type | Description +:----- | :----------------- | :---------- +`code` | [`Cell{:tact}`][cell] | initial code of the [contract](/book/contracts) (the compiled bytecode) +`data` | [`Cell{:tact}`][cell] | initial data of the [contract](/book/contracts) (arguments of `init(){:tact}` function of the contract) + +[p]: /book/types#primitive-types +[cell]: /book/cells#cells +[s]: /book/structs-and-messages#structs +[m]: /book/structs-and-messages#messages diff --git a/docs/src/content/docs/book/external.mdx b/docs/src/content/docs/book/external.mdx new file mode 100644 index 000000000..b16385e7d --- /dev/null +++ b/docs/src/content/docs/book/external.mdx @@ -0,0 +1,75 @@ +--- +title: External Messages +--- + +:::caution + External message support must be enabled explicitly in the project configuration. + Without enabling it compilation would fail. +::: + +External messages are those that don't have a sender and can be sent by anyone in the world. External messages are good tools for integrating with off-chain systems or for the general maintenance of contracts. Handling external messages is different from handling internal messages. In this section, we will cover how to handle external messages. + +## How External Messages are Different + +External messages are different from internal messages in the following ways: + +### Contracts Pay for Gas Usage Themselves + +When processing internal messages, the sender usually pays for gas usage. When processing external messages, the contract pays for gas usage. This means that you need to be careful with gas usage in external messages. You should always test the gas usage of your contracts and verify that everything is working as intended. + +### Messages Have to Be Accepted Manually + +External messages are not accepted automatically. You need to accept them manually. This is done by calling the `acceptMessage` function. If you don't call the `acceptMessage` function, the message will be rejected. This is done to prevent the spamming of external messages. + +### 10k Gas Limit Before Message Acceptance + +10k gas is a very small limit, and Tact itself can consume a sizable amount of gas before it even reaches your code. You should always test the gas usage of your contracts and verify that everything is working as intended. + +:::tip[Hey there!] + The 10k gas limit for external messages is based on the parameter we set by the + validator for the whole blockchain of the `gas_limit` field. You can take + the reference here: + - https://docs.ton.org/develop/smart-contracts/guidelines/accept#external-messages + - https://docs.ton.org/develop/howto/blockchain-configs#param-20-and-21 + + ::: + +### Unbounded Gas Usage After Message Acceptance + +After you accept the gas, the contract can use as much gas as it wants. This is done to allow the contract to carry out any kind of processing. You should always test the gas usage of your contracts and verify that everything is working as intended, and avoid possible vulnerabilities that could drain the contract balance. + +### No Context Available + +When processing an external message, the `context` and `sender` functions are not available. This is because there is no context available for external messages. This means that you can't use the `context` and `sender` functions in external messages. You need to carefully test your contract to make sure that it doesn't use the `context` and `sender` functions. + +## Enable External Messages Support + +To enable external messages support, please enable it in the project configuration file: + +```json +{ + "options": { + "external": true + } +} +``` + +## External receivers + +External receivers are defined the same way as internal ones, but using the `external` keyword instead of `receive`: + +```tact +contract SampleContract { + external("Check Timeout") { + + // Check for contract timeout + require(self.timeout > now(), "Not timeouted"); + + // Accept message + acceptMessage(); + + // Timeout processing + self.onTimeouted(); + } +} +``` diff --git a/docs/src/content/docs/book/func.mdx b/docs/src/content/docs/book/func.mdx new file mode 100644 index 000000000..c491a8f7b --- /dev/null +++ b/docs/src/content/docs/book/func.mdx @@ -0,0 +1,306 @@ +--- +title: Compatibility with FunC +--- + +Tact itself compiles to FunC and maps all its entities directly to various FunC and TL-B types. + +## Convert types + +[Primitive types](/book/types#primitive-types) in Tact are directly mapped to FunC ones. + +All rules about copying variables are the same. One of the big differences is that there are no visible mutation operators in Tact and most [`Slice{:tact}`](/book/cells#slices) operations mutate variables in place. + +## Convert serialization + +Serialization of [Structs](/book/structs-and-messages#structs) and [Messages](/book/structs-and-messages#messages) in Tact is automatic, unlike FunC where you need to define serialization logic manually. + +Tact's auto-layout algorithm is greedy. This means that it takes the next variable, calculates its size, and tries to fit it into a current cell. If it doesn't fit, it creates a new cell and continues. All inner structs for auto-layout are flattened before allocation. + +All optional types are serialized as `Maybe` in TL-B, except for [`Address{:tact}`](/book/types#primitive-types). + +There is no support for `Either` since it does not define what to pick during serialization in some cases. + +### Examples + +```tact +// _ value1:int257 = SomeValue; +struct SomeValue { + value1: Int; // Default is 257 bits +} +``` + +```tact +// _ value1:int256 value2:uint32 = SomeValue; +struct SomeValue { + value1: Int as int256; + value2: Int as uint32; +} +``` + +```tact +// _ value1:bool value2:Maybe bool = SomeValue; +struct SomeValue { + value1: Bool; + value2: Bool?; +} +``` + +```tact +// _ cell:^cell = SomeValue; +struct SomeValue { + cell: Cell; // Always stored as a reference +} +``` + +```tact +// _ cell:^slice = SomeValue; +struct SomeValue { + cell: Slice; // Always stored as a reference +} +``` + +```tact +// _ value1:int256 value2:int256 value3:int256 ^[value4:int256] = SomeValue; +struct SomeValue { + value1: Int as int256; + value2: Int as int256; + value3: Int as int256; + value4: Int as int256; +} +``` + +```tact +// _ value1:int256 value2:int256 value3:int256 ^[value4:int256] flag:bool = SomeValue; +struct SomeValue { + value1: Int as int256; + value2: Int as int256; + value3: Int as int256; + flag: Bool; // Flag is written before value4 to avoid auto-layout to allocate it to the next cell + value4: Int as int256; +} +``` + +```tact +// _ value1:int256 value2:int256 value3:int256 ^[value4:int256 flag:bool] = SomeValue; +struct SomeValue { + value1: Int as int256; + value2: Int as int256; + value3: Int as int256; + value4: Int as int256; + flag: Bool; +} +``` + +```tact +// _ value1:int256 value2:^TailString value3:int256 = SomeValue; +struct SomeValue { + value1: Int as int256; + value2: String; + value3: Int as int256; +} +``` + +## Convert received messages to `op` operations + +Tact generates a unique `op` for every received typed message, but it can be overwritten. + +The following code in FunC: + +```func +() recv_internal(int msg_value, cell in_msg_cell, slice in_msg) impure { + ;; incoming message code... + + ;; Receive MessageWithGeneratedOp message + if (op == 1180414602) { + ;; code... + } + + ;; Receive MessageWithOverwrittenOP message + if (op == 291) { + ;; code... + } + +} +``` + +Becomes this in Tact: + +```tact +message MessageWithGeneratedOp { + amount: Int as uint32; +} + +message(0x123) MessageWithOverwrittenOP { + amount: Int as uint32; +} + +contract Contract { + // Contract Body... + + receive(msg: MessageWithGeneratedOp) { + // code... + } + + receive(msg: MessageWithOverwrittenOP) { + // code... + } + +} +``` + +## Convert `get`-methods + +You can express everything except `list-style-lists` in Tact that would be compatible with FunC's `get`-methods. + +### Primitive return type + +If a `get`-method returns a primitive in FunC, you can implement it the same way in Tact. + +The following code in FunC: + +```func +int seqno() method_id { + return 0; +} +``` + +Becomes this in Tact: + +```tact +get fun seqno(): Int { + return 0; +} +``` + +### Tensor return types + +In FunC there is a difference between tensor type `(int, int){:func}` and `(int, (int)){:func}`, but for TVM there are no differences, they all represent a stack of two integers. + +To convert the tensor that returned from a FunC `get`-method, you need to define a [Struct](/book/structs-and-messages#structs) that has the same field types as the tensor and in the same order. + +The following code in FunC: + +```func +(int, slice, slice, cell) get_wallet_data() method_id { + return ...; +} +``` + +Becomes this in Tact: + +```tact +struct JettonWalletData { + balance: Int; + owner: Address; + master: Address; + walletCode: Cell; +} + +contract JettonWallet { + get fun get_wallet_data(): JettonWalletData { + return ...; + } +} +``` + +### Tuple return type + +In FunC if you are returning a tuple, instead of a tensor you need to follow the process for a tensor type, but define the return type of a `get`-method as optional. + +The following code in FunC: + +```func +[int, int] get_contract_state() method_id { + return ...; +} +``` + +Becomes this in Tact: + +```tact +struct ContractState { + valueA: Int; + valueB: Int; +} + +contract StatefulContract { + get fun get_contract_state(): ContractState? { + return ...; + } +} +``` + +### Mixed tuple and tensor return types + +When some of the tensors are a tuple, you need to define a struct as in previous steps and the tuple one must be defined as a separate [Struct](/book/structs-and-messages#structs). + +The following code in FunC: + +```func +(int, [int, int]) get_contract_state() method_id { + return ...; +} +``` + +Becomes this in Tact: + +```tact +struct ContractStateInner { + valueA: Int; + valueB: Int; +} + +struct ContractState { + valueA: Int; + valueB: ContractStateInner; +} + +contract StatefulContract { + get fun get_contract_state(): ContractState { + return ...; + } +} +``` + +### Arguments mapping + +Conversion of `get`-methods arguments is straightforward. Each argument is mapped _as-is_ to FunC one, and each tuple is mapped to a [Struct](/book/structs-and-messages#structs). + +The following code in FunC: + +```func +(int, [int, int]) get_contract_state(int arg1, [int,int] arg2) method_id { + return ...; +} +``` + +Becomes this in Tact: + +```tact +struct ContractStateArg2 { + valueA: Int; + valueB: Int; +} + +struct ContractStateInner { + valueA: Int; + valueB: Int; +} + +struct ContractState { + valueA: Int; + valueB: ContractStateInner; +} + +contract StatefulContract { + get fun get_contract_state(arg1: Int, arg2: ContractStateArg2): ContractState { + return ContractState{ + valueA: arg1, + valueB: ContractStateInner{ + valueA: arg2.valueA, + valueB: arg2.valueB, // trailing comma is allowed + }, // trailing comma is allowed + }; + } +} +``` diff --git a/docs/src/content/docs/book/functions.mdx b/docs/src/content/docs/book/functions.mdx new file mode 100644 index 000000000..10e8f32d4 --- /dev/null +++ b/docs/src/content/docs/book/functions.mdx @@ -0,0 +1,137 @@ +--- +title: Functions and their types +--- + +Functions in Tact could be defined in different ways: + +* Global static function +* Extension functions +* Mutable functions +* Native functions +* Receiver functions +* Getter functions + +All functions, except for [receiver functions](#receiver-functions) can have a trailing comma in their definitions (parameter lists) and calls (argument lists): + +```tact +fun foo( + a: Int, // trailing comma in parameter lists is allowed +) {} + +fun bar() { + foo( + 5, // trailing comma in argument lists is allowed too! + ); +} +``` + +## Global static functions + +You can define global function anywhere in your program: + +```tact +fun customPow(a: Int, c: Int): Int { + let res: Int = 1; + repeat(c) { + res *= a; + } + return res; +} +``` + +## Virtual and abstract functions + +You can allow the contract inheriting a [traits](/book/types#traits) to modify an internal function, if it has the `virtual{:tact}` keyword, using `override{:tact}`. The function can be also marked as `abstract{:tact}`, in which case the inheriting contract has to define its implementation: + +```tact +trait FilterTrait with Ownable { + // Virtual functions can be overridden by users of this trait + virtual fun filterMessage(): Bool { + return sender() != self.owner; + } + + abstract fun specialFilter(): Bool; +} + +contract Filter with FilterTrait { + // Overriding default behavior of the FilterTrait + override fun filterMessage(): Bool { + return true; + } + + override fun specialFilter(): Bool { + return true; + } +} +```` + +## Extension function + +Extension functions allow you to implement extensions for any possible type. + +> **Warning** +> The name of the first argument MUST be named `self` and the type of this argument is the type you are extending. + +```tact +extends fun customPow(self: Int, c: Int): Int { + let res: Int = 1; + repeat(c) { + res *= self; + } + return res; +} +``` + +## Mutable functions + +Mutable functions are performing mutation of a value replacing it with an execution result. To perform mutation, the function must change the `self` value. + +```tact +extends mutates fun customPow(self: Int, c: Int) { + let res: Int = 1; + repeat(c) { + res *= self; + } + self = res; +} +``` + +## Native functions + +Native functions are direct bindings of FunC functions: + +> **Note** +> Native functions could be also mutable and extension ones. + +```tact +@name(store_uint) +native storeUint(s: Builder, value: Int, bits: Int): Builder; + +@name(load_int) +extends mutates native loadInt(self: Slice, l: Int): Int; +``` + +## Receiver functions + +Receiver functions are special functions that are responsible for receiving messages in contracts and could be defined only within a contract or trait. + +```tact +contract Treasure { + // This means that this contract can receive the comment "Increment" and this function would be called for such messages + receive("Increment") { + self.counter += 1; + } +} +``` + +## Getter Functions + +Getter functions define getters on smart contracts and can be defined only within a contract or trait. + +```tact +contract Treasure { + get fun counter(): Int { + return self.counter; + } +} +``` diff --git a/docs/src/content/docs/book/import.mdx b/docs/src/content/docs/book/import.mdx new file mode 100644 index 000000000..ec60ce2d5 --- /dev/null +++ b/docs/src/content/docs/book/import.mdx @@ -0,0 +1,54 @@ +--- +title: Importing code +--- + +Tact allows you to import Tact and [FunC](https://docs.ton.org/develop/func/overview) code — any given `.tact` or `.fc`/`.func` file can be imported into your project using the `import{:tact}` keyword. + +Additionally, Tact compiler has a versatile set of standard libraries, which come bundled in, but not included right away, see [Standard libraries overview](/ref/standard-libraries). + +:::caution + + NOTE: All imported code is combined together with yours, so it's important to avoid name collisions and always double-check the sources! + +::: + +## Import Tact code + +It's possible to import any Tact code using the `import{:tact}` statement and providing a relative path to the target `.tact` file like so: + +```tact +import "./relative/path/to/the/target/tact/file.tact"; +``` + +Specifying parent directories (`../`) is also possible: + +```tact +import "../subfolder/imported/file.tact"; +``` + +## Import FunC code + +It's possible to import code written in FunC code directly just as it's done with Tact code imports: + +```tact +// Relative import +import "./relative/path/to/the/target/func/file.fc"; + +// Specifying parent directories +import "../subfolder/imported/func/file.fc"; +``` + +But in order to use functions from such file, one has to declare them as `native` functions first. For example, when standard library [@stdlib/dns](/ref/stdlib-dns) uses a `dns.fc` FunC file, it maps FunC functions to Tact ones like so: + +```tact +// FunC code located in a file right next to the current Tact one: +import "./dns.fc"; + +// Mapping function signatures from FunC to Tact: +@name(dns_string_to_internal) +native dnsStringToInternal(str: String): Slice?; +``` + +## Standard libraries + +See [Standard libraries overview](/ref/standard-libraries). diff --git a/docs/src/content/docs/book/index.mdx b/docs/src/content/docs/book/index.mdx new file mode 100644 index 000000000..247dfa0e9 --- /dev/null +++ b/docs/src/content/docs/book/index.mdx @@ -0,0 +1,39 @@ +--- +title: Book overview +--- + +import { LinkCard, CardGrid, Steps } from '@astrojs/starlight/components'; + +Welcome to **The Tact Book** section (or just **The Book**), — an introductory book about the Tact language. + +Here are its main contents: + + + +1. #### Cheatsheets + + [Cheatsheets](/book/cs/from-func) are quick rundowns on Tact syntax and idioms with comparison to other blockchain languages, such as FunC (also on TON) and Solidity (Ethereum blockchain). Use those to transition to Tact as swiftly as possible. + + + + + +2. #### Book + + [**The Tact Book**](/book/types) is a cohesive and streamlined sequence of educational materials about Tact. In general, it assumes that you’re reading it in sequence from front to back. Later parts build on concepts in earlier parts, and earlier parts might not delve into details on a particular topic but will revisit the topic in a later part. + + Additionally, there are many references to the Language section of the documentation, where many primitives of the language are described in much more fine detail. Additionally, whenever there's an existing explanation of the broader TON concept in the main TON documentation, this Book tries to reference it as well. + + Book also assumes that you’ve written code in another programming language but doesn’t make any assumptions about which one. We’ve tried to make the material broadly accessible to those from a wide variety of programming backgrounds. We don’t spend a lot of time talking about what programming _is_ or how to think about it. If you’re entirely new to programming, you would be better served by reading a book that specifically provides an introduction to programming. + + + + + + diff --git a/docs/src/content/docs/book/integers.mdx b/docs/src/content/docs/book/integers.mdx new file mode 100644 index 000000000..5b1d6af13 --- /dev/null +++ b/docs/src/content/docs/book/integers.mdx @@ -0,0 +1,184 @@ +--- +title: Integers +--- + +Arithmetic in smart contracts on TON is always done with integers and never with floating-point numbers since the floats are [unpredictable](https://learn.microsoft.com/en-us/cpp/build/why-floating-point-numbers-may-lose-precision). Therefore, the big accent goes on integers and their handling. + +The only primitive number type in Tact is `Int{:tact}`, for $257$-bit signed integers.\ +It's capable of storing integers between $-2^{256}$ and $2^{256} - 1.$ + +## Notation + +Tact supports various ways of writing primitive values of `Int{:tact}` as [integer literals](/book/expressions#integer-literals). + +Most of the notations allow adding underscores (`_`) in-between digits, except for: +* Representations in strings, as seen in [nano-tons](#nanotoncoin) case. +* Decimal numbers written with a leading zero $0.$ Their use is generally discouraged, see [below](#decimal). + +Additionally, several underscores in a row as in $4\_\_2$, or trailing underscores as in $42\_$ are **not** allowed. + +### Decimal + +Most common and most used way of representing numbers, using the [decimal numeral system](https://en.wikipedia.org/wiki/Decimal): $123456789.$\ +You can use underscores (`_`) to improve readability: $123\_456\_789$ is equal to $123456789.$ + +:::caution + Alternatively, you can prefix the number with one $0$, which prohibits use of underscores and only allows decimal digits: $0123 = 123.$ + Note, that using this notation with leading zero is **strongly discouraged** due to possible confusion with octal integer literals in TypeScript, which is often used alongside Tact to develop and test contracts. +::: + +### Hexadecimal + +Represent numbers using [hexadecimal numeral system](https://en.wikipedia.org/wiki/Hexadecimal), denoted by the $\mathrm{0x}$ (or $\mathrm{0X}$) prefix: $\mathrm{0xFFFFFFFFF}.$\ +Use underscores (`_`) to improve readability: $\mathrm{0xFFF\_FFF\_FFF}$ is equal to $\mathrm{0xFFFFFFFFF}.$ + +### Octal + +Represent numbers using [octal numeral system](https://en.wikipedia.org/wiki/Octal), denoted by the $\mathrm{0o}$ (or $\mathrm{0O}$) prefix: $\mathrm{0o777777777.}$\ +Use underscores (`_`) to improve readability: $\mathrm{0o777\_777\_777}$ is equal to $\mathrm{0o777777777}.$ + +### Binary + +Represent numbers using [binary numeral system](https://en.wikipedia.org/wiki/Binary_number), denoted by the $\mathrm{0b}$ (or $\mathrm{0B}$) prefix: $\mathrm{0b111111111.}$\ +Use underscores (`_`) to improve readability: $\mathrm{0b111\_111\_111}$ is equal to $\mathrm{0b111111111}.$ + +### NanoToncoin + +Arithmetic with dollars requires two decimal places after the dot — those are used for the cents value. But how would we represent the number \$$1.25$ if we're only able to work with integers? The solution is to work with _cents_ directly. This way, \$$1.25$ becomes $125$ cents. We simply memorize that the two rightmost digits represent the numbers after the decimal point. + +Similarly, working with Toncoin, the main currency of TON Blockchain, requires nine decimal places instead of the two. One can say that nanoToncoin is the $\frac{1}{10^{9}}\mathrm{th}$ of the Toncoin. + +Therefore, the amount of $1.25$ Toncoin, which can be represented in Tact as [`ton("1.25"){:tact}`](/ref/core-comptime#ton), is actually the number $1250000000$. We refer to such numbers as _nanoToncoin(s)_ (or _nano-ton(s)_) rather than _cents_. + +## Serialization + +When encoding `Int{:tact}` values to persistent state (fields of [contracts](/book/contracts) and [traits](/book/types#traits)), it's usually better to use smaller representations than $257$-bits to reduce [storage costs](https://docs.ton.org/develop/smart-contracts/fees#storage-fee). Usage of such representations is also called "serialization" due to them representing the native [TL-B][tlb] types which TON Blockchain operates on. + +The persistent state size is specified in every declaration of a state variable after the `as{:tact}` keyword: + +```tact +contract SerializationExample { + // persistent state variables + oneByte: Int as int8 = 0; // ranges from -128 to 127 (takes 8 bit = 1 byte) + twoBytes: Int as int16; // ranges from -32,768 to 32,767 (takes 16 bit = 2 bytes) + + init() { + // needs to be initialized in the init() because it doesn't have the default value + self.twoBytes = 55*55; + } +} +``` + +Integer serialization is also available for the fields of [Structs](/book/structs-and-messages#structs) and [Messages](/book/structs-and-messages#messages), as well as in key/value types of [maps](/book/maps): + +```tact +struct StSerialization { + martin: Int as int8; +} + +message MsgSerialization { + seamus: Int as int8; + mcFly: map; +} +``` + +Motivation is very simple: +* Storing $1000$ $257$-bit integers in state [costs](https://docs.ton.org/develop/smart-contracts/fees#how-to-calculate-fees) about $0.184$ TON per year. +* Storing $1000$ $32$-bit integers only costs $0.023$ TON per year by comparison. + +### Serialization types + +Name | [TL-B][tlb] | Inclusive range | Space taken +:--------------: | :-------------------------: | :-------------------------: | :------------------------: +`uint8{:tact}` | [`uint8`][tlb-builtin] | $0$ to $2^{8} - 1$ | $8$ bits = $1$ byte +`uint16{:tact}` | [`uint16`][tlb-builtin] | $0$ to $2^{16} - 1$ | $16$ bits = $2$ bytes +`uint32{:tact}` | [`uint32`][tlb-builtin] | $0$ to $2^{32} - 1$ | $32$ bits = $4$ bytes +`uint64{:tact}` | [`uint64`][tlb-builtin] | $0$ to $2^{64} - 1$ | $64$ bits = $8$ bytes +`uint128{:tact}` | [`uint128`][tlb-builtin] | $0$ to $2^{128} - 1$ | $128$ bits = $16$ bytes +`uint256{:tact}` | [`uint256`][tlb-builtin] | $0$ to $2^{256} - 1$ | $256$ bits = $32$ bytes +`int8{:tact}` | [`int8`][tlb-builtin] | $-2^{7}$ to $2^{7} - 1$ | $8$ bits = $1$ byte +`int16{:tact}` | [`int16`][tlb-builtin] | $-2^{15}$ to $2^{15} - 1$ | $16$ bits = $2$ bytes +`int32{:tact}` | [`int32`][tlb-builtin] | $-2^{31}$ to $2^{31} - 1$ | $32$ bits = $4$ bytes +`int64{:tact}` | [`int64`][tlb-builtin] | $-2^{63}$ to $2^{63} - 1$ | $64$ bits = $8$ bytes +`int128{:tact}` | [`int128`][tlb-builtin] | $-2^{127}$ to $2^{127} - 1$ | $128$ bits = $16$ bytes +`int256{:tact}` | [`int256`][tlb-builtin] | $-2^{255}$ to $2^{255} - 1$ | $256$ bits = $32$ bytes +`int257{:tact}` | [`int257`][tlb-builtin] | $-2^{256}$ to $2^{256} - 1$ | $257$ bits = $32$ bytes + $1$ bit +`coins{:tact}` | [`VarUInteger 16`][varuint] | $0$ to $2^{120} - 1$ | between $4$ and $124$ bits, [see below](#serialization-coins) + +### Variable `coins` type {#serialization-coins} + +In Tact, `coins{:tact}` is an alias to [`VarUInteger 16`][varuint] in [TL-B][tlb] representation, i.e. it takes a variable bit length depending on the optimal number of bytes needed to store the given integer and is commonly used for storing [nanoToncoin](/book/integers#nanotoncoin) amounts. + +This serialization format consists of two [TL-B fields](https://docs.ton.org/develop/data-formats/tl-b-language#field-definitions): + +* `len`, a $4$-bit unsigned big-endian integer storing the byte length of the value provided +* `value`, a $8 * len$-bit unsigned big-endian representation of the value provided + +That is, integers serialized as `coins{:tact}` occupy between $4$ and $124$ bits ($4$ bits for `len` and $0$ to $15$ bytes for `value`) and have values in the inclusive range from $0$ to $2^{120} - 1$. + +Examples: + +```tact +struct Scrooge { + // len: 0000, 4 bits (always) + // value: none! + // in total: 4 bits + a: Int as coins = 0; // 0000 + + // len: 0001, 4 bits + // value: 00000001, 8 bits + // in total: 12 bits + b: Int as coins = 1; // 0001 00000001 + + // len: 0010, 4 bits + // value: 00000001 00000010, 16 bits + // in total: 20 bits + c: Int as coins = 258; // 0010 00000001 00000010 + + // len: 1111, 4 bits + // value: hundred twenty 1's in binary + // in total: 124 bits + d: Int as coins = pow(2, 120) - 1; // hundred twenty 1's in binary +} +``` + +:::note + + Read more on serialization here: [Compatibility with FunC](/book/func#convert-serialization) + +::: + +## Operations + +All runtime calculations with numbers are done at 257-bits, so [overflows](https://en.wikipedia.org/wiki/Integer_overflow) are quite rare. Nevertheless, if any math operation overflows, an exception will be thrown, and the transaction will fail. You could say that Tact's math is safe by default. + +Note, that there is no problem with mixing variables of [different state sizes](#serialization) in the same calculation. At runtime they are all the same type no matter what — $257$-bit signed, so overflows won't happen then. + +However, this can still lead to **errors** in the [compute phase](https://docs.ton.org/learn/tvm-instructions/tvm-overview#compute-phase) of the transaction. Consider the following example: + +```tact +import "@stdlib/deploy"; + +contract ComputeErrorsOhNo with Deployable { + oneByte: Int as uint8; // persistent state variable, max value is 255 + + init() { + self.oneByte = 255; // initial value is 255, everything fits + } + + receive("lets break it") { + let tmp: Int = self.oneByte * 256; // no runtime overflow + self.oneByte = tmp; // whoops, tmp value is out of the expected range of oneByte + } +} +``` + +Here, `oneByte` is serialized as a [`uint8`](#serialization-types), which occupies only one byte and ranges from $0$ to $2^{8} - 1$, which is $255$. And when used in runtime calculations no overflow happens and everything is calculated as a $257$-bit signed integers. But the very moment we decide to store the value of `tmp` back into `oneByte` we get an error with the [exit code 5](/book/exit-codes#5), which states the following: `Integer out of the expected range`. + +:::caution + Therefore, be **very** careful with numbers and always double-check calculations when using serialization. +::: + +[tlb]: https://docs.ton.org/develop/data-formats/tl-b-language +[tlb-builtin]: https://docs.ton.org/develop/data-formats/tl-b-language#built-in-types +[varuint]: https://docs.ton.org/develop/data-formats/msg-tlb#varuinteger-n diff --git a/docs/src/content/docs/book/lifecycle.mdx b/docs/src/content/docs/book/lifecycle.mdx new file mode 100644 index 000000000..4b5485b04 --- /dev/null +++ b/docs/src/content/docs/book/lifecycle.mdx @@ -0,0 +1,28 @@ +--- +title: Message Lifecycle +--- + +There are several stages of message processing by a contract, there are more of them, but we would focus on the most important ones: + +## Receive Phase + +This phase combines multiple low-level phases. + +It starts by adding a **message value to the contract balance**. The value of an incoming message is the maximum price that a contract can pay for gas to process this message. The contract can overwrite this limit, but it is not recommended and is suitable only for advanced developers since it could lead to a contract being drained. 1 million of gas is the maximum amount that a contract can spend in a single contract which equals 0.4 TON for basechain (currently). If the message value is zero then execution is aborted. + +Then some (usually small) amount of nanotons gets subtracted from the contract balance for storage. This means that you can't perfectly predict balance changes and have to adjust your code to this instability. + +Then it deploys a contract if it is not deployed yet and the message contains the init package. If the init package isn't present, it will be ignored. + +## Compute Phase + +This phase executes the code of a smart contract and produces a list of actions or an exception. Currently, only two types of actions are supported: **send message** and **reserve**. + +Sending a message could use a fixed value or a dynamic value like **remaining value of a message** - the remaining value of the incoming message. Sending a message could be with a flag `SendIgnoreErrors` that would ignore errors during message sending and would continue to the next action. This flag is useful if you have multiple actions. When sending a message with some value, it first subtracts this value from the incoming value and only then from the contract balance (before processing). + +## Action Phase + +Actions are executed in sequence, but bear in mind: +**EXCEPTION DURING PROCESSING ACTIONS WOULDN'T REVERT THE TRANSACTION** + +For example, if you subtract 1 ton from a customer's balance and then send an invalid message, that could lead to a situation when the customer's balance is subtracted, but he wouldn't receive it. diff --git a/docs/src/content/docs/book/maps.mdx b/docs/src/content/docs/book/maps.mdx new file mode 100644 index 000000000..7f01b599b --- /dev/null +++ b/docs/src/content/docs/book/maps.mdx @@ -0,0 +1,331 @@ +--- +title: Maps +--- + +The [composite type](/book/types#composite-types) `map{:tact}` is used as a way to associate keys of type `K{:tact}` with corresponding values of type `V{:tact}`. + +For example, `map{:tact}` uses [`Int{:tact}`][int] type for its keys and values: + +```tact +struct IntToInt { + counters: map; +} +``` + +## Allowed types + +Allowed key types: + +* [`Int{:tact}`][int] +* [`Address{:tact}`][p] + +Allowed value types: + +* [`Int{:tact}`][int] +* [`Bool{:tact}`](/book/types#booleans) +* [`Cell{:tact}`][cell] +* [`Address{:tact}`][p] +* [Struct](/book/structs-and-messages#structs) +* [Message](/book/structs-and-messages#messages) + +## Operations + +### Declare, `emptyMap()` {#emptymap} + +As a [local variable](/book/statements#let), using `emptyMap(){:tact}` function of standard library: + +```tact +let fizz: map = emptyMap(); +let fizz: map = null; // identical to the previous line, but less descriptive +``` + +As a [persistent state variable](/book/contracts#variables): + +```tact +contract Example { + fizz: map; // Int keys to Int values + init() { + self.fizz = emptyMap(); // redundant and can be removed! + } +} +``` + +Note, that [persistent state variables](/book/contracts#variables) of type `map{:tact}` are initialized empty by default and don't need default values or an initialization in the [`init(){:tact}` function](/book/contracts#init-function). + +### Set values, `.set()` {#set} + +To set or replace the value under a key call the `.set(){:tact}` [method](/book/functions#extension-function), which is accessible for all maps. + +```tact +// Empty map +let fizz: map = emptyMap(); + +// Setting a couple of values under different keys +fizz.set(7, 7); +fizz.set(42, 42); + +// Overriding one of the existing key-value pairs +fizz.set(7, 68); // key 7 now points to value 68 +``` + +### Get values, `.get()` {#get} + +To check if a key is found in the map by calling the `.get(){:tact}` [method](/book/functions#extension-function), which is accessible for all maps. This will return `null{:tact}` if the key is missing, or the value if the key is found. + +```tact +// Empty map +let fizz: map = emptyMap(); + +// Setting a value +fizz.set(68, 0); + +// Getting the value by its key +let gotButUnsure: Int? = fizz.get(68); // returns Int or null, therefore the type is Int? +let mustHaveGotOrErrored: Int = fizz.get(68)!!; // explicitly asserting that the value must not be null, + // which may crush at runtime if the value is, in fact, null + +// Alternatively, we can check for the key in the if statement +if (gotButUnsure != null) { + // Hooray, let's use !! without fear now and cast Int? to Int + let definitelyGotIt: Int = fizz.get(68)!!; +} else { + // Do something else... +} +``` + +### Delete entries, `.del()` {#del} + +To delete a single key-value pair (single entry), use the `.del(){:tact}` [method](/book/functions#extension-function). It returns `true{:tact}` in the case of successful deletion and `false{:tact}` otherwise. + +```tact +// Empty map +let fizz: map = emptyMap(); + +// Setting a couple of values under different keys +fizz.set(7, 123); +fizz.set(42, 321); + +// Deleting one of the keys +let deletionSuccess: Bool = fizz.del(7); // true, because map contained the entry under key 7 +fizz.del(7); // false, because map no longer has an entry under key 7 + +// Note, that assigning the `null` value to the key when using the `.set()` method +// is equivalent to calling `.del()`, although such approach is much less descriptive +// and is generally discouraged: +fizz.set(42, null); // the entry under key 42 is now deleted +``` + +To delete all the entries from the map, re-assign the map using the `emptyMap(){:tact}` function: + +```tact +// Empty map +let fizz: map = emptyMap(); + +// Setting a couple of values under different keys +fizz.set(7, 123); +fizz.set(42, 321); + +// Deleting all of the entries at once +fizz = emptyMap(); +fizz = null; // identical to the previous line, but less descriptive +``` + +With this approach all previous entries of the map are completely discarded from the contract even if the map was declared as its persistent state variable. As a result, assigning maps to `emptyMap(){:tact}` **does not** inflict any hidden or sudden [storage fees](https://docs.ton.org/develop/smart-contracts/fees#storage-fee). + +### Check if empty, `.isEmpty()` {#isempty} + +The `.isEmpty(){:tact}` [method](/book/functions#extension-function) on maps returns `true{:tact}` if the map is empty and `false{:tact}` otherwise: + +```tact +let fizz: map = emptyMap(); + +if (fizz.isEmpty()) { + dump("Empty maps are empty, duh!"); +} + +// Note, that comparing the map to `null` behaves the same as `.isEmpty()` method, +// although such direct comparison is much less descriptive and is generally discouraged: +if (fizz == null) { + dump("Empty maps are null, which isn't obvious"); +} +``` + +### Convert to a `Cell`, `.asCell()` {#ascell} + +Use `.asCell(){:tact}` [method](/book/functions#extension-function) on maps to convert all their values to a [`Cell{:tact}`][cell] type. Be mindful, that [`Cell{:tact}`][cell] type is able to store up to 1023 bits, so converting larger maps to the Cell will result in error. + +As an example, this method is useful for sending small maps directly in the body of the reply: + +```tact +contract Example { + // Persistent state variables + fizz: map; // our map + + // Constructor (initialization) function of the contract + init() { + // Setting a bunch of values + self.fizz.set(0, 3); + self.fizz.set(1, 14); + self.fizz.set(2, 15); + self.fizz.set(3, 926); + self.fizz.set(4, 5_358_979_323_846); + } + + // Internal message receiver, which responds to empty messages + receive() { + // Here we're converting the map to a Cell and making a reply with it + self.reply(self.fizz.asCell()); + } +} +``` + +### Traverse over entries {#traverse} + +To iterate over map entries there is a [`foreach{:tact}`](/book/statements#foreach-loop) loop statement: + +```tact +// Empty map +let fizz: map = emptyMap(); + +// Setting a couple of values under different keys +fizz.set(42, 321); +fizz.set(7, 123); + +// Iterating over in a sequential order: from the smallest keys to the biggest ones +foreach (key, value in fizz) { + dump(key); // will dump 7 on the first iteration, then 42 on the second +} +``` + +Read more about it: [`foreach{:tact}` loop in Book→Statements](/book/statements#foreach-loop). + +Note, that it's also possible to use maps as simple arrays if you define a `map{:tact}` with an [`Int{:tact}`][int] type for the keys, any allowed `V{:tact}` type for values and keep track of the number of items in the separate variable: + +```tact +contract Iteration { + // Persistent state variables + counter: Int as uint32; // counter of map entries, serialized as a 32-bit unsigned + record: map; // Int to Address map + + // Constructor (initialization) function of the contract + init() { + self.counter = 0; // Setting the self.counter to 0 + } + + // Internal message receiver, which responds to a String message "Add" + receive("Add") { + // Get the Context Struct + let ctx: Context = context(); + // Set the entry: counter Int as a key, ctx.sender Address as a value + self.record.set(self.counter, ctx.sender); + // Increase the counter + self.counter += 1; + } + + // Internal message receiver, which responds to a String message "Send" + receive("Send") { + // Loop until the value of self.counter (over all the self.record entries) + let i: Int = 0; // declare usual i for loop iterations + while (i < self.counter) { + send(SendParameters{ + bounce: false, // do not bounce back this message + to: self.record.get(i)!!, // set the sender address, knowing that key i exists in the map + value: ton("0.0000001"), // 100 nanoToncoins (nano-tons) + mode: SendIgnoreErrors, // send ignoring errors in transaction, if any + body: "SENDING".asComment() // String "SENDING" converted to a Cell as a message body + }); + i += 1; // don't forget to increase the i + } + } + + // Getter function for obtaining the value of self.record + get fun map(): map { + return self.record; + } + + // Getter function for obtaining the value of self.counter + get fun counter(): Int { + return self.counter; + } +} +``` + +It's often useful to set an upper-bound restriction on such maps, so that you [don't hit the limits](#limits-and-drawbacks). + +:::caution + + Note, that manually keeping track of number of items or checking the length of such map is very error-prone and generally discouraged. Instead, try to wrap your map into the [Struct](/book/structs-and-messages#structs) and define [extension functions](/book/functions#extension-function) on it. See example in the Cookbook: [How to emulate an array using a map wrapped in a Struct](/cookbook/data-structures#array). + +::: + +:::note + + This example was adapted from [howardpen9/while-example-tact](https://github.com/howardpen9/while-example-tact/blob/de5807fcd20dba5f6a3748d112511477fb22bfcc/contracts/awesome.tact#L19C10-L19C10). + + See other examples of map usage in the Cookbook:\ + [How to emulate a stack using a map wrapped in a Struct](/cookbook/data-structures#stack)\ + [How to emulate a circular buffer using a map wrapped in a Struct](/cookbook/data-structures#circular-buffer) + +::: + +## Serialization + +It's possible to do [integer serialization](/book/integers#serialization-types) of map keys, values or both to [preserve space and reduce storage costs](/book/integers#serialization): + +```tact +struct SerializedMapInside { + // Both keys and values here would be serialized as 8-bit unsigned integers, + // thus preserving the space and reducing storage costs: + countersButCompact: map; +} +``` + +:::note + + Read about other serialization options: [Compatibility with FunC](/book/func#convert-serialization). + +::: + +## Limits and drawbacks + +While maps can be convenient to work with on a small scale, they cause a number of issues if the number of items is unbounded and map can significantly grow in size: + +* As the upper bound of the smart contract state size is around $65\,000$ items of type [`Cell{:tact}`][cell], it constrains the storage limit of maps to be about $30\,000$ key-value pairs for the whole contract. + +* The more entries you have in a map, the bigger [compute fees](https://docs.ton.org/develop/howto/fees-low-level#computation-fees) you'll get. Thus, working with large maps makes compute fees tough to predict and manage. + +* Using a large map in a single contract doesn't allow to distribute its workload. Hence, it can make the overall performance much worse compared to using a smaller map and a bunch of interacting smart contracts. + +To resolve such issues you can set an upper-bound restriction on a map as a constant and check against it every time you're setting a new value to the map: + +```tact +contract Example { + // Declare a compile-time constant upper-bound for our map + const MaxMapSize: Int = 42; + + // Persistent state variables + arr: map; // "array" of Int values as a map + arrLength: Int = 0; // length of the "array", defaults to 0 + + // Internal function for pushing an item to the end of the "array" + fun arrPush(item: Int) { + if (self.arrLength >= self.MaxMapSize) { + // Do something, stop the operation, for example + } else { + // Proceed with adding new item + self.arr.set(self.arrLength, item); + self.arrLength += 1; + } + } +} +``` + +If you still need a large map or an unbound (infinitely large) map, it's better to architect your smart contracts according to the [asynchronous and actor-based model of TON blockchain](https://docs.ton.org/learn/overviews/ton-blockchain). That is, to use contract sharding and essentially make the whole blockchain a part of your map(s). + +{/* + TODO: Add reference to sharding page as per: https://github.com/tact-lang/tact-docs/issues/155 +*/} + +[p]: /book/types#primitive-types +[int]: /book/integers +[cell]: /book/cells#cells diff --git a/docs/src/content/docs/book/masterchain.mdx b/docs/src/content/docs/book/masterchain.mdx new file mode 100644 index 000000000..16e337f9e --- /dev/null +++ b/docs/src/content/docs/book/masterchain.mdx @@ -0,0 +1,49 @@ +--- +title: Masterchain +--- + +:::caution + + Masterchain addresses are treated as invalid unless the `masterchain` option in the [configuration file](/book/config) is set to `true{:json}`. + +::: + +In TON Blockchain, a special chain called ["masterchain"](https://docs.ton.org/learn/overviews/ton-blockchain#masterchain-blockchain-of-blockchains) is used to synchronize message routing and transaction execution, so that nodes in the network can fix a particular point in a multi-chain state and reach a consensus about that state. + +Masterchain stores the [network configuration](/ref/core-advanced#getconfigparam) and the final state of all [workchains](https://docs.ton.org/learn/overviews/ton-blockchain#workchain-blockchain-with-your-own-rules). It carries fundamental protocol information, including current settings, a list of active validators and their stakes, active workchains, and associated [shardchains](https://docs.ton.org/develop/blockchain/shards). Most importantly, it maintains a record of the latest block hashes for all workchains and shardchains, enforcing consensus across the network. + +## How contract is protected from masterchain {#protection} + +Tact enforces all contracts to use the [basechain](https://docs.ton.org/develop/blockchain/shards), which is the default workchain with ID $0$. This is done to prevent masterchain addresses from being used in the contract. + +Any attempts to point to masterchain or otherwise interact with it without [enabling masterchain support](#support) throw an exception with [exit code 137](/book/exit-codes#137): `Masterchain support is not enabled for this contract`. + +That is, accidental deployments to the masterchain, receiving messages from masterchain accounts, sending messages to such accounts, and using masterchain addresses or its chain ID ($-1$) are all prohibited by default. + +## Enabling masterchain support in compilation options {#support} + +:::caution + +Most contracts don't need to be deployed on a masterchain or have any interactions on a masterchain. That's because the masterchain is primarily used for voting or storing libraries. If you don't need to partake in those things, you don't need to enable masterchain support. + +::: + +If you really do need masterchain support, the simplest and recommended approach is to modify a [`tact.config.json`](/book/config) file in the root of your project (or create it if it didn't exist yet), and [set the `masterchain` property to `true{:json}`](/book/config#options-masterchain). + +If you're working on a [Blueprint][bp]-based project, you can enable masterchain support in the compilation configs of your contracts, which are located in a directory named `wrappers/`: + +```typescript title="wrappers/YourContractName.compile.ts" {7} +import { CompilerConfig } from '@ton/blueprint'; + +export const compile: CompilerConfig = { + lang: 'tact', + target: 'contracts/your_contract_name.tact', + options: { + masterchain: true, // ← that's the stuff! + } +}; +``` + +However, [`tact.config.json`](/book/config) may still be used in [Blueprint][bp] projects. In such cases values specified in [`tact.config.json`](/book/config) act as default unless modified in the `wrappers/`. + +[bp]: https://github.com/ton-org/blueprint diff --git a/docs/src/content/docs/book/message-mode.mdx b/docs/src/content/docs/book/message-mode.mdx new file mode 100644 index 000000000..21017945c --- /dev/null +++ b/docs/src/content/docs/book/message-mode.mdx @@ -0,0 +1,59 @@ +--- +title: Message mode +--- + +As it was previously mentioned, messages are sent with the `mode` param of a struct `SendParameters{:tact}`. It's an [`Int{:tact}`][int] value, which is combined from base modes and optional flags, which are also [`Int{:tact}`][int] values. + +It's possible to use raw [`Int{:tact}`][int] values and manually provide them for the `mode`, but for your convenience there's a set of constants which you may use to construct the compound `mode` with ease. Take a look at the following tables for more information on base modes and optional flags. + +## Base modes + +Mode value | Constant name | Description +---------: | :---------------------------- | ----------- +$0$ | - | Ordinary message (default). +$64$ | `SendRemainingValue{:tact}` | Carry all the remaining value of the inbound message in addition to the value initially indicated in the new message. +$128$ | `SendRemainingBalance{:tact}` | Carry all the remaining balance of the current smart contract instead of the value originally indicated in the message. + +## Optional flags + +Flag value | Constant name | Description +---------: | :------------------------------ | ----------- +$+1$ | `SendPayGasSeparately{:tact}` | Pay forward fees separately from the message value. +$+2$ | `SendIgnoreErrors{:tact}` | Ignore any errors arising while processing this message during the action phase. +$+16$ | `SendBounceIfActionFail{:tact}` | Bounce transaction in case of any errors during action phase. Has no effect if flag $+2$, `SendIgnoreErrors{:tact}` is used. +$+32$ | `SendDestroyIfZero{:tact}` | Current account must be destroyed if its resulting balance is zero (often used with mode $128$, `SendRemainingBalance{:tact}`). + +## Combining modes with flags + +To make the [`Int{:tact}`][int] value for `mode` field of `SendParameters{:tact}`, you just have to combine base modes with optional flags by applying the [bitwise OR](/book/operators#binary-bitwise-or) operation. + +For example, if you want to send a regular message and pay transfer fees separately, use the mode $0$ (default) and a flag $+1$ to get `mode` $= 1$, which is equal to using `SendPayGasSeparately{:tact}` constant. + +Alternatively, if you want to send the whole contract balance and destroy it immediately, use the mode $128$ and flag $+32$ to get `mode` $= 160$, which is equal to `SendRemainingBalance | SendDestroyIfZero{:tact}`. + +Here's how the latter example would look in code: + +```tact +let to: Address = ...; +let value: Int = ton("1"); +send(SendParameters{ + to: to, + value: value, + mode: SendRemainingBalance | SendDestroyIfZero, + body: "Hello, World!".asComment(), +}); +``` + +:::caution + + Note, that while adding ([`+{:tact}`](/book/operators#binary-add)) base modes together with optional flags is possible, it is discouraged due to the possibility of excess values. Use the bitwise OR ([`|{:tact}`](/book/operators#binary-bitwise-or)) instead, as it's designed to work with such flag and bit manipulations of the `mode`. + +::: + +:::note + + Also note, that there can be only one [base mode](#base-modes), but number of [optional flags](#optional-flags) may vary: you can use them all, none or just some. + +::: + +[int]: /book/integers diff --git a/docs/src/content/docs/book/operators.mdx b/docs/src/content/docs/book/operators.mdx new file mode 100644 index 000000000..b0f17f083 --- /dev/null +++ b/docs/src/content/docs/book/operators.mdx @@ -0,0 +1,652 @@ +--- +title: Operators +--- + +Almost every contract operates on data: transforms some values into another. Scope may vary, but operators lay in core of such modifications. + +This page lists all the operators in Tact in decreasing order of their [precedence](#precedence), with examples of usage. + +:::note + + Note, that there are no implicit type conversions in Tact, so operators can't be used to, say, add values of different type or compare them in terms of equality without explicitly casting to the same type. That's done with certain functions from the standard library. See [`Int.toString(){:tact}`](/ref/core-strings#inttostring) for an example of such function. + +::: + +## Table of operators {#table} + +The following table lists operators in order of decreasing [precedence](#precedence): from highest to lowest. + +Brief description | Operators +:---------------- | :-------------------------------------------------------------------- +Parentheses | [`(){:tact}`][paren] +Unary postfix | [`!!{:tact}`][nna] +Unary prefix | [`+{:tact}`][plus]   [`-{:tact}`][neg]   [`!{:tact}`][inv]   [`~{:tact}`][b-not] +Multiplicative | [`*{:tact}`][mul]   [`/{:tact}`][div]   [`%{:tact}`][mod] +Additive | [`+{:tact}`][add]   [`-{:tact}`][sub] +Shift | [`>>{:tact}`][shr]   [`<<{:tact}`][shl] +Relation | [`>{:tact}`][gt]   [`>={:tact}`][ge]   [`<{:tact}`][lt]   [`<={:tact}`][le] +Equality | [`=={:tact}`][eq]   [`!={:tact}`][eq] +Bitwise AND | [`&{:tact}`][b-and] +Bitwise XOR | [`^{:tact}`][b-xor] +Bitwise OR | [`\|{:tact}`][b-or] +Logical AND | [`&&{:tact}`][l-and] +Logical OR | [`\|\|{:tact}`][l-or] +Ternary | [`?:{:tact}`][ternary] +Assignment | [`={:tact}`][assign] and [all augmented assignment operators](#augmented-assignment) + +[paren]: #parentheses + +[nna]: #unary-non-null-assert +[plus]: #unary-plus +[neg]: #unary-negate +[inv]: #unary-inverse +[b-not]: #unary-bitwise-not + +[mul]: #binary-multiply +[div]: #binary-divide +[mod]: #binary-modulo + +[add]: #binary-add +[sub]: #binary-subtract + +[shr]: #binary-bitwise-shift-right +[shl]: #binary-bitwise-shift-left + +[gt]: #binary-greater +[ge]: #binary-greater-equal +[lt]: #binary-less +[le]: #binary-less-equal + +[eq]: #binary-equality + +[b-and]: #binary-bitwise-and +[b-xor]: #binary-bitwise-xor +[b-or]: #binary-bitwise-or + +[l-and]: #binary-logical-and +[l-or]: #binary-logical-or + +[ternary]: #ternary + +[assign]: #assignment + +## Precedence + +All operators on this page are given in order of decreasing precedence, from highest to lowest. Precedence is used to choose which operator would be considered in a particular situation. Whenever any ambiguity arises, Tact would prefer operators with higher precedence over those with lower. + +For example, minus sign (`-{:tact}`) may be considered as a subtraction operator or as a negation operator, which reverses the sign of the expression from plus to minus, or vice-versa. As the latter has the higher precedence over the former in cases of ambiguity between the two Tact will first consider `-{:tact}` as a negation operator. And if that doesn't make sense for the given expression, only then it would consider it as a subtraction operator. + +Consider the following code: + +```tact +5 + -5; // here, the minus sign would be viewed as a negation operator +5 -5; // while here it would be viewed as a subtraction operator, despite formatting +``` + +Even though this example may be simple, neglecting of precedence rules can often lead to confusing situations with operators. The correct order of operations can be ensured by wrapping every operation in [parentheses](#parentheses), since parentheses have the highest precedence of all expressions and operators there is. + +## Parentheses, `()` {#parentheses} + +Parentheses (also can be called round brackets, `(){:tact}`) are more of a punctuation symbols than actual operators, but their [precedence](#precedence) is higher than precedence of any other operator. Use parentheses to override order of operations: + +```tact +5 * 5 - 2; // 23 +5 * (5 - 2); // 15 +``` + +## Unary + +Unary here means that they are applied only to one operand of the given expression. All unary operators, except for the [non-null assertion](#unary-non-null-assert), are of the same [precedence](#precedence). + +Unary operators can be one of the two types: + +* prefix — placed before the expression. +* postfix (or suffix) — placed after the expression. + +### Non-null assert, `!!` {#unary-non-null-assert} + +Unary double-exclamation mark (_non-null assertion_) operator `!!{:tact}` is a postfix operator, which enforces non-`null{:tact}` values and allows direct access to the value of the optional variable if it's not `null{:tact}`. Otherwise, raises a compilation error if the compiler can track it, and if not — throws an exception with [exit code 128](/book/exit-codes#128): `Null reference exception`. Can be applied to any optional variable regardless of its non-`null{:tact}` type. + +:::note + + Read more about optional variables and fields here: [Optionals](/book/optionals) + +::: + +### Plus, `+` {#unary-plus} + +Although unary plus sign operator `+{:tact}` is specified in the grammar of Tact compiler, it only exists as a [binary operator](#binary-add). + +### Negate, `-` {#unary-negate} + +Unary minus sign (_negation_) operator `-{:tact}` is a prefix operator, which reverses the sign of the expression. Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let five: Int = 5; +five + -five; // here, the minus sign is a negation operator, not a subtraction operator +-(-1); // double application gives back the original value, which is 1 +--1; // 1 +``` + +### Inverse, `!` {#unary-inverse} + +Unary exclamation mark (_inversion_) operator `!{:tact}` is a prefix operator, which inverts the boolean value of the expression — changes `true{:tact}` to `false{:tact}`, and vice versa. Can only be applied to values of type [`Bool{:tact}`][bool]: + +```tact +let iLikeTact: Bool = true; +!iLikeTact; // false +!false; // true +!(!false); // false +!!false; // false +``` + +### Bitwise NOT, `~` {#unary-bitwise-not} + +Unary tilde (_bitwise not_) operator `~{:tact}` is a prefix operator, which inverts or _flips_ each bit in the binary representation of the expression — changes each $1$ to $0$, and vice versa. Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let answer: Int = 42; +~answer; // -43 +~(~answer); // 42 +~(~0); // 0 +~~0; // 0 +``` + +## Binary + +Binary operators are split into several subsections, in order of decreasing [precedence](#precedence). Operators within each subsection have the same [precedence](#precedence) as the subsection itself. + +### Multiplication {#binary-multiplication} + +Multiply, divide or obtain a remainder. + +#### Multiply, `*` {#binary-multiply} + +Binary asterisk (_multiplication_) operator `*{:tact}` is used for multiplication of two values. Can cause [integer overflows](/book/integers#operations). + +Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two * two; // 4 +0 * 1_000_000_000; // 0 +-1 * 5; // -5 + +pow(2, 255) * pow(2, 255); // build error: integer overflow! +``` + +#### Divide, `/` {#binary-divide} + +Binary slash (_division_) operator `/{:tact}` is used for integer division of two values, which truncates towards zero if result is positive, and away from zero if result is negative. This is also called [rounding down](https://en.wikipedia.org/wiki/Rounding#Rounding_down) (or rounding towards $-∞$). + +An attempt to divide by zero would result in an error with [exit code 4](/book/exit-codes#4): `Integer overflow`. + +Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two / 2; // 1 +two / 1; // 2 +-1 / 5; // -1 +-1 / -5; // 0 +1 / -5; // -1 +1 / 5; // 0 +6 / 5; // 1, rounding down +-6 / 5; // -2, rounding down (towards -∞) +``` + +:::note + + Note that the following relationship between the division and modulo operators always holds for `Int{:tact}` type: + + ```tact + a / b * b + a % b == a; // true for any Int values of `a` and `b`, + // except when `b` is equal to 0 and we divide `a` by 0, + // which is an attempt to divide by zero resulting in an error + ``` + +::: + +#### Modulo, `%` {#binary-modulo} + +Binary percent sign (_modulo_) operator `%{:tact}` is used for getting the modulo of an integer division, which must not be confused with getting a remainder. For two values of the same sign, modulo and remainder operations are equivalent, but when the operands are of different signs, the modulo result always has the same sign as the _divisor_ (value on the right), while the remainder has the same sign as the _dividend_ (value on the left), which can make them differ by one unit of the _divisor_. + +Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two % 2; // 0 +two % 1; // 1 + +1 % 5; // 1 +-1 % 5; // 4 +1 % -5; // -4 +-1 % -5; // -1 +``` + +The simplest way to avoid confusion between the two is to prefer using positive values via [`abs(x: Int){:tact}`](/ref/core-math#abs): + +```tact +abs(-1) % abs(-5); // 1 +``` + +:::note + + Did you know, that in JavaScript `%{:tact}` works as a _remainder_ operator, but not _modulo_ operator (like in Tact)?\ + [Remainder (%) - JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Remainder#description)\ + [Modulo - Wikipedia](https://en.wikipedia.org/wiki/Modulo) + +::: + +### Addition {#binary-addition} + +Add or subtract. + +#### Add, `+` {#binary-add} + +Binary plus (_addition_) operator `+{:tact}` is used for adding numbers together. Going beyond the maximum value of an [`Int{:tact}`][int] will result in an error with [exit code 4](/book/exit-codes#4): `Integer overflow`. + +Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two + 2; // 4 +-1 + 1; // 0 + +pow(2, 254) + pow(2, 254); // 2 * 2^254 +pow(2, 255) + pow(2, 255); // build error: integer overflow! +pow(2, 255) - 1 + pow(2, 255); // 2^256 - 1, maximal value of any integer in Tact! +``` + +#### Subtract, `-` {#binary-subtract} + +Binary minus (_subtraction_) operator `-{:tact}` is used for subtracting numbers from each other. Going beyond the minimum value of an [`Int{:tact}`][int] will result in an error with [exit code 4](/book/exit-codes#4): `Integer overflow`. + +Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two - 2; // 0 +-1 - 1; // -2 + +pow(2, 254) - pow(2, 254); // 0 +pow(2, 255) - pow(2, 255); // 0 +pow(2, 256) - pow(2, 256); // build error: integer overflow! +``` + +### Bitwise shifts {#binary-bitwise-shifts} + +Shift bits to the left or to the right. + +#### Shift right, `>>` {#binary-bitwise-shift-right} + +Binary double greater than (_bitwise shift right_) operator `>>{:tact}` returns an integer which binary representation is the _left operand_ value shifted by the _right operand_ number of bits to the right. Excess bits shifted off to the right are discarded, and copies of the leftmost bit are shifted in from the left. This operation is also called "sign-propagating right shift" or "arithmetic right shift", because the sign of the resulting number is the same as the sign of the _left operand_. This is a more effective way to divide the _left operand_ by $2^n$, where $n$ is equal to the _right operand_. + +Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two >> 1; // 1 +4 >> 1; // 2 +5 >> 1; // 2, due to flooring of integer values + +pow(2, 254) >> 254; // 1 +``` + +:::note + + [Bit shifts - Wikipedia](https://en.wikipedia.org/wiki/Bitwise_operation#Bit_shifts)\ + [Bit manipulation - Wikipedia](https://en.wikipedia.org/wiki/Bit_manipulation) + +::: + +#### Shift left, `<<` {#binary-bitwise-shift-left} + +Binary double greater than (_bitwise shift left_) operator `<<{:tact}` returns an integer which binary representation is the _left operand_ value shifted by the _right operand_ number of bits to the left. Excess bits shifted off to the left are discarded, and zero bits are shifted in from the right. This is a more effective way to multiply the _left operand_ by $2^n$, where $n$ is equal to the _right operand_. Going beyond the maximum value of an [`Int{:tact}`][int] will result in an error with [exit code 4](/book/exit-codes#4): `Integer overflow`. + +Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two << 1; // 4 +1 << 5; // 1 * 2^5, which is 32 +2 << 5; // 2 * 2^5, which is 64 + +pow(2, 254) == (1 << 254); // true +pow(2, 254) == 1 << 254; // true, no parentheses needed due to higher precedence of >> over == +pow(2, 255) == 1 << 255; // true, but we're very close to overflow here! +``` + +:::note + + [Bit shifts - Wikipedia](https://en.wikipedia.org/wiki/Bitwise_operation#Bit_shifts)\ + [Bit manipulation - Wikipedia](https://en.wikipedia.org/wiki/Bit_manipulation) + +::: + +### Relation {#binary-relation} + +Find bigger, smaller or equal values. + +#### Greater than, `>` {#binary-greater} + +Binary _greater than_ operator `>{:tact}` returns `true{:tact}` if the left operand is greater than the right operand, and `false{:tact}` otherwise. Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two > 2; // false +-1 > -3; // true +``` + +#### Greater than or equal to, `>=` {#binary-greater-equal} + +Binary _greater than or equal to_ operator `>={:tact}` returns `true{:tact}` if the left operand is greater than or to the right operand, and `false{:tact}` otherwise. Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two >= 2; // true +-1 >= -3; // true +``` + +#### Less than, `<` {#binary-less} + +Binary _less than_ operator `<{:tact}` returns `true{:tact}` if the left operand is less than the right operand, and `false{:tact}` otherwise. Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two < 2; // false +-1 < -3; // false +``` + +#### Less than or equal to, `<=` {#binary-less-equal} + +Binary _less than or equal to_ operator `<={:tact}` returns `true{:tact}` if the left operand is less than or equal to the right operand, and `false{:tact}` otherwise. Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two <= 2; // true +-1 <= -3; // false +``` + +### Equality and inequality, `==` `!=` {#binary-equality} + +Binary equality (_equal_) operator `=={:tact}` checks whether its two operands are _equal_, returning a result of type [`Bool{:tact}`][bool]. + +Binary inequality (_not equal_) operator `!={:tact}` checks whether its two operands are _not equal_, returning a result of type [`Bool{:tact}`][bool]. + +Both operators require operands to be of the same type and both don't perform implicit type conversions, except for the [`Cell{:tact}`][cell] and [`Slice{:tact}`][slice] types, which are implicitly compared by their hashes. + +Both operators can be applied to the following list of types and values: + +* [`Int{:tact}`][int] +* [`Bool{:tact}`][bool] +* [`Address{:tact}`][p] +* [`Cell{:tact}`][cell], implicitly compares via `.hash(){:tact}` +* [`Slice{:tact}`][slice], implicitly compares via `.hash(){:tact}` +* [`String{:tact}`][p] +* [`map{:tact}`](/book/maps), but only if their key and value types are identical +* [Optionals and `null{:tact}` value](/book/optionals) + +```tact +// Int: +2 == 3; // false +2 != 3; // true + +// Bool: +true == true; // true +false != true; // true + +// Address: +myAddress() == myAddress(); // true +myAddress() != myAddress(); // false + +// Cell: +emptyCell() == emptyCell(); // true +emptyCell() != emptyCell(); // false + +// Slice: +"A".asSlice() == "A".asSlice(); // true +"A".asSlice() != "A".asSlice(); // false + +// String: +"A" == "A"; // true +"A" != "A"; // false + +// map: +let map1: map = emptyMap(); +let map2: map = emptyMap(); +map1 == map2; // true +map1 != map2; // false + +// Optionals and null values themselves +let nullable: Int? = null; +nullable == null; // true +null == null; // true +nullable != null; // false +null != null; // false + +let anotherNullable: Int? = 5; +nullable == anotherNullable; // false +nullable != anotherNullable; // true +``` + +### Bitwise AND, `&` {#binary-bitwise-and} + +Binary ampersand (_bitwise AND_) operator `&{:tact}` applies a [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND), which performs the [logical AND](#binary-logical-and) operation on each pair of the corresponding bits of operands. This is useful when we want to clear selected bits off a number, where each bit represents an individual flag or a boolean state, which makes it possible to "store" up to $257$ boolean values per integer, as all integers in Tact are $257$-bit signed. + +Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two & 1; // 0 +4 & 1; // 0 +3 & 1; // 1 +1 & 1; // 1 + +255 & 0b00001111; // 15 +0b11111111 & 0b00001111; // 15 +``` + +:::note + + [Bitwise AND - Wikipedia](https://en.wikipedia.org/wiki/Bitwise_operation#AND)\ + [Bit manipulation - Wikipedia](https://en.wikipedia.org/wiki/Bit_manipulation) + +::: + +### Bitwise XOR, `^` {#binary-bitwise-xor} + +Binary caret (_bitwise XOR_) operator `^{:tact}` applies a [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR), which performs the [logical exclusive OR](https://en.wikipedia.org/wiki/Exclusive_or) operation on each pair of the corresponding bits of operands. The result in each position is $1$ if only one of the bits is $1$, but will be $0$ if both are $0$ or both are $1$. In this it performs the comparison of two bits, giving $1$ if the two bits are different, and $0$ if they are the same. + +It is useful for inverting selected bits of an operand (also called toggle or flip), as any bit may be toggled by "XORing" it with $1$. + +Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two ^ 3; // 1 +4 ^ 1; // 0 +3 ^ 1; // 3 +1 ^ 1; // 0 + +255 ^ 0b00001111; // 240 +0b11111111 ^ 0b00001111; // 240 +``` + +:::note + + [Bitwise XOR - Wikipedia](https://en.wikipedia.org/wiki/Bitwise_operation#XOR)\ + [Bit manipulation - Wikipedia](https://en.wikipedia.org/wiki/Bit_manipulation) + +::: + +### Bitwise OR, `|` {#binary-bitwise-or} + +Binary bar (_bitwise OR_) operator `|{:tact}` applies a [bitwise OR](https://en.wikipedia.org/wiki/Bitwise_operation#OR), which performs the [logical OR](#binary-logical-or) operation on each pair of the corresponding bits of operands. This is useful when we want to apply a specific [bitmask](https://en.wikipedia.org/wiki/Mask_(computing)). + +For example, _bitwise OR_ is commonly used in Tact to [combine base modes with optional flags](/book/message-mode#combining-modes-with-flags) by masking specific bits to $1$ in order to construct a target [message `mode`](/book/message-mode). + +Can only be applied to values of type [`Int{:tact}`][int]: + +```tact +let two: Int = 2; +two | 1; // 3 +4 | 1; // 5 +3 | 1; // 3 +1 | 1; // 1 + +255 | 0b00001111; // 255 +0b11111111 | 0b00001111; // 255 +``` + +:::note + + [Bitwise OR - Wikipedia](https://en.wikipedia.org/wiki/Bitwise_operation#OR)\ + [Bit manipulation - Wikipedia](https://en.wikipedia.org/wiki/Bit_manipulation) + +::: + +### Logical AND, `&&` {#binary-logical-and} + +Binary logical AND ([logical conjunction](https://en.wikipedia.org/wiki/Logical_conjunction)) operator `&&{:tact}` returns `true{:tact}` if both operands are `true{:tact}`, and `false{:tact}` otherwise. It's short-circuited, meaning that it would immediately evaluate the whole expression as `false{:tact}` if the left operand is `false{:tact}`, without evaluating the right one. + +Can only be applied to values of type [`Bool{:tact}`][bool]: + +```tact +let iLikeTact: Bool = true; +iLikeTact && true; // true, evaluated both operands +iLikeTact && false; // false, evaluated both operands +false && iLikeTact; // false, didn't evaluate iLikeTact +``` + +### Logical OR, `||` {#binary-logical-or} + +Binary logical OR ([logical disjunction](https://en.wikipedia.org/wiki/Logical_disjunction)) operator `||{:tact}` returns `false{:tact}` only if both operands are `false{:tact}`, and `true{:tact}` otherwise. It's short-circuited, meaning that it would immediately evaluate the whole expression as `true{:tact}` if the left operand is `true{:tact}`, without evaluating the right one. + +Can only be applied to values of type [`Bool{:tact}`][bool]: + +```tact +let iLikeSnails: Bool = false; +iLikeSnails || true; // true, evaluated both operands +iLikeSnails || false; // false, evaluated both operands +true || iLikeSnails; // true, didn't evaluate iLikeSnails +``` + +## Ternary, `?:` {#ternary} + +Conditional (_ternary_) operator is the only Tact operator that takes three operands: a condition followed by a question mark (`?{:tact}`), then an expression to execute if the condition is evaluated to `true{:tact}` followed by a colon (`:{:tact}`), and finally the expression to execute if the condition is evaluated to `false{:tact}`. This operator is frequently used as an alternative to an [`if...else{:tact}`](/book/statements#if-else) statement. + +Condition must resolve to type [`Bool{:tact}`][bool]: + +```tact +// condition +// ↓ +true ? "incredibly so" : "absolutely not"; // "incredibly so" +// --------------- ---------------- +// ↑ ↑ +// | alternative, when condition is false +// | +// consequence, when condition is true + +2 + 2 == 4 ? true : false; // true +``` + +Ternary operator is the only operator with right associativity, besides [assignment-related ones](#assignment). This means that in ambiguous situations Tact would prefer the longest matching sequence. In short, this makes bracket-less nesting of ternary operators possible, but only for alternative cases (the part that comes after the colon sign `:{:tact}`): + +```tact +// don't need additional parentheses for alternative cases +false ? 1 : (false ? 2 : 3); // 3 +false ? 1 : false ? 2 : 3; // also 3 +false ? 1 : true ? 2 : 3; // 2 + +// need additional parentheses for consequence cases (parts in-between ? and :) +false ? (false ? 1 : 2) : 3; // 3 +false ? false ? 1 : 2 : 3; // SYNTAX ERROR! +true ? (false ? 1 : 2) : 3; // 2 +``` + +## Assignment, `=` {#assignment} + +Assignment operator `={:tact}` is used to assign a value to a variable, or to a property of a [Message](/book/structs-and-messages#messages) or a [Struct](/book/structs-and-messages#structs). The assignment is a statement and it doesn't return a value. + +```tact +let someVar: Int = 5; // assignment operator = is used here... +someVar = 4; // ...and here +someVar = (someVar = 5); // SYNTAX ERROR! +``` + +### Augmented assignment + +Augmented (or compound) assignment operators such as `+={:tact}` combine an operation with an [assignment](#assignment). The augmented assignment is a statement and it doesn't return a value. + +Augmented assignments are semantically equivalent to regular assignments, but with an operation: + +```tact +let value: Int = 5; + +// this: +value += 5; +// is equivalent to this: +value = value + 5; +``` + +List of augmented assignment operators: + +* `+={:tact}`, which uses [addition operator `+{:tact}`](#binary-add). Can only be applied to values of type [`Int{:tact}`][int]. +* `-={:tact}`, which uses [subtraction operator `-{:tact}`](#binary-subtract). Can only be applied to values of type [`Int{:tact}`][int]. +* `*={:tact}`, which uses [multiplication operator `*{:tact}`](#binary-multiply). Can only be applied to values of type [`Int{:tact}`][int]. +* `/={:tact}`, which uses [division operator `/{:tact}`](#binary-divide). Can only be applied to values of type [`Int{:tact}`][int]. +* `%={:tact}`, which uses [modulo operator `%{:tact}`](#binary-modulo). Can only be applied to values of type [`Int{:tact}`][int]. +* `&={:tact}`, which uses [bitwise AND operator `&{:tact}`](#binary-bitwise-and). Can only be applied to values of type [`Int{:tact}`][int]. +* `^={:tact}`, which uses [bitwise XOR operator `^{:tact}`](#binary-bitwise-xor). Can only be applied to values of type [`Int{:tact}`][int]. +* `|={:tact}`, which uses [bitwise OR operator `|{:tact}`](#binary-bitwise-or). Can only be applied to values of type [`Int{:tact}`][int]. + +```tact +let value: Int = 5; + +// += +value + 5; // adds 5 +value = value + 5; // adds 5 and assigns result back +value += 5; // also adds 5 and assigns result back + +// -= +value - 5; // subtracts 5 +value = value - 5; // subtracts 5 and assigns result back +value -= 5; // also subtracts 5 and assigns result back + +// *= +value * 5; // multiplies by 5 +value = value * 5; // multiplies by 5 and assigns result back +value *= 5; // also multiplies by 5 and assigns result back + +// /= +value / 5; // divides by 5 +value = value / 5; // divides by 5 and assigns result back +value /= 5; // also divides by 5 and assigns result back + +// %= +value % 5; // gets modulo by 5 +value = value % 5; // gets modulo by 5 and assigns result back +value %= 5; // also gets modulo by 5 and assigns result back + +// &= +value & 5; // bitwise ANDs 5 +value = value & 5; // bitwise ANDs 5 and assigns result back +value &= 5; // also bitwise ANDs 5 and assigns result back + +// ^= +value ^ 5; // bitwise XORs 5 +value = value ^ 5; // bitwise XORs 5 and assigns result back +value ^= 5; // also bitwise XORs 5 and assigns result back + +// |= +value | 5; // bitwise ORs 5 +value = value | 5; // bitwise ORs 5 and assigns result back +value |= 5; // also bitwise ORs 5 and assigns result back +``` + +[p]: /book/types#primitive-types +[bool]: /book/types#booleans +[int]: /book/integers +[cell]: /book/cells#cells +[slice]: /book/cells#slices diff --git a/docs/src/content/docs/book/optionals.mdx b/docs/src/content/docs/book/optionals.mdx new file mode 100644 index 000000000..5f2c800fb --- /dev/null +++ b/docs/src/content/docs/book/optionals.mdx @@ -0,0 +1,42 @@ +--- +title: Optionals +--- + +As it was mentioned in [type system overview](/book/types#optionals), all [primitive types](/book/types#primitive-types), [Structs](/book/structs-and-messages#structs) and [Messages](/book/structs-and-messages#messages) could be nullable. That is, they don't necessarily hold any value, aside from `null{:tact}` — a special value, which represents the intentional absence of any other value. + +[Variables](/book/statements#let) or fields of [Structs](/book/structs-and-messages#structs) and [Messages](/book/structs-and-messages#messages) that can hold `null{:tact}` are called "optionals". They're useful to reduce state size when the variable isn't necessarily used. + +You can make any variable or a field an optional by adding a question mark (`?{:tact}`) after its type declaration. The only exceptions are [`map{:tact}`](/book/maps) and [`bounced{:tact}`](/book/bounced), where you can't make them, inner key/value type (in case of a map) or the inner [Message](/book/structs-and-messages#messages) (in case of a bounced) optional. + +Optional variables or optional fields that are not defined hold the `null{:tact}` value by default. You cannot access them without checking for `null{:tact}` first. But if you're certain they are not `null{:tact}` at a given moment, use the [non-null assertion operator `!!{:tact}`](/book/operators#unary-non-null-assert) to access their value. + +Trying to access the value of an optional variable or an optional field without using [`!!{:tact}`](/book/operators#unary-non-null-assert) or without checking for `null{:tact}` beforehand will result in a compilation error if the compiler can track it, and if not — in an exception with [exit code 128](/book/exit-codes#128): `Null reference exception`. + +Example of optionals: + +```tact +struct StOpt { + opt: Int?; // Int or null +} + +message MsOpt { + opt: StOpt?; // Notice, how the struct StOpt is used in this definition +} + +contract Optionals { + opt: Int?; + address: Address?; + + init(opt: Int?) { // optionals as parameters + self.opt = opt; + self.address = null; // explicit null value + } + + receive(msg: MsOpt) { + let opt: Int? = 12; // defining a new variable + if (self.opt != null) { // explicit check + self.opt = opt!!; // using !! as we know that opt value isn't null + } + } +} +``` diff --git a/docs/src/content/docs/book/programmatic.mdx b/docs/src/content/docs/book/programmatic.mdx new file mode 100644 index 000000000..c93651c34 --- /dev/null +++ b/docs/src/content/docs/book/programmatic.mdx @@ -0,0 +1,47 @@ +--- +title: Programmatic API +--- + +You can invoke the Tact compiler from your code in node and browser environments. + +:::caution + + This API has not been released yet. It will be released in the 1.0.0 version. + +::: + +## Run compiler in browser + +```ts +import { run } from "@tact-lang/compiler"; + +// Virtual FS +const fs = { + ["main.tact"]: Buffer.from("...").toString("base64"), +}; + +const config = { + projects: [ + { + name: "Sample", + path: "main.tact", + output: "./output", + }, + ], +}; + +// Run compiler +let successful = await run({ config, fs }); + +// NOTE: Output from is written to the same fs object. +``` + +## Contract verification + +You can always verify the compiled package with the `verify` function. + +```ts +import { verify } from "@tact-lang/compiler"; +const pkg: string = '...'; +const res = await verify(pkg); +``` diff --git a/docs/src/content/docs/book/receive.mdx b/docs/src/content/docs/book/receive.mdx new file mode 100644 index 000000000..a47a5e06a --- /dev/null +++ b/docs/src/content/docs/book/receive.mdx @@ -0,0 +1,53 @@ +--- +title: Receive messages +--- + +TON is a distributed blockchain which means that communication between contracts is done by sending and receiving messages. The most common type of message is the internal message - a message sent from one contract (or a wallet) to another. + +## Receive internal messages + +To receive a message of the required type, you need to declare a receiver function, for example, `receive("increment"){:tact}`. This notation means the declaration of a receiver function that will be called when a text with the value `"increment"{:tact}` is sent to the contract. The function body can modify the state of the contract and send messages to other contracts. It is impossible to call a receiver directly. If you need to reuse some logic you can declare a function and call it from the receiver. + +There are several receiver functions. All receiver functions are processed in the order they are listed below: + +* `receive(){:tact}` - called when an empty message is sent to the contract +* `receive("message"){:tact}` - called when a text message with a specific comment is sent to the contract +* `receive(str: String){:tact}` - called when an arbitrary text message is sent to the contract +* `receive(msg: MyMessage){:tact}` - called when a binary message of type `MyMessage` is sent to the contract +* `receive(msg: Slice){:tact}` - called when binary message of unknown type is sent to the contract + +```tact +message MyMessage { + value: Int; +} + +contract MyContract { + receive() { + // ... + } + receive("message") { + // ... + } + receive(str: String) { + // ... + } + receive(msg: MyMessage) { + // ... + } + receive(msg: Slice) { + // ... + } +} +``` + +Naming a parameter of the receiver function with an underscore `_{:tact}` makes its value considered unused and discarded. This is useful when you don't need to inspect the message received and you only want it to convey a specific opcode: + +```tact +message(42) UniverseCalls {} + +contract Example { + receive(_: UniverseCalls) { + // Got a Message with opcode 42 + } +} +``` diff --git a/docs/src/content/docs/book/send.mdx b/docs/src/content/docs/book/send.mdx new file mode 100644 index 000000000..9d6fccd10 --- /dev/null +++ b/docs/src/content/docs/book/send.mdx @@ -0,0 +1,158 @@ +--- +title: Sending messages +--- + +TON blockchain is message-based — to communicate with other contracts and to deploy new ones you need to send messages. + +Messages in Tact are commonly composed using a built-in [Struct](/book/structs-and-messages#structs) `SendParameters{:tact}`, which consists of: + +Field | Type | Description +:------- | :--------------------- | :---------- +`bounce` | [`Bool{:tact}`][p] | When set to `true` (default) message bounces back to the sender if the receiver contract doesn't exist or wasn't able to process the message. +`to` | [`Address{:tact}`][p] | Receiver internal [`Address{:tact}`][p] in TON blockchain. +`value` | [`Int{:tact}`][int] | The amount of [nanoToncoins][nano] you want to send with the message. This value is usually used to cover [forward fees][fwdfee], unless the optional flag [`SendPayGasSeparately{:tact}`](/book/message-mode#optional-flags) is used. +`mode` | [`Int{:tact}`][int] | An 8-bit value that configures how to send a message, defaults to $0$. See: [Message `mode`](/book/message-mode). +`body` | [`Cell?{:tact}`][cell] | [Optional][opt] message body as a [`Cell{:tact}`][cell] +`code` | [`Cell?{:tact}`][cell] | [Optional][opt] initial code of the contract (the compiled bytecode) +`data` | [`Cell?{:tact}`][cell] | [Optional][opt] initial data of the contract (arguments of [`init(){:tact}` function](/book/contracts#init-function) of the contract) + +Fields `code` and `data` are what's called an [init package](/book/expressions#initof), which is used in deployments of new contracts. + +## Send simple reply + +The simplest message is a reply to the incoming message returning all excess value of a message: + +```tact +receive() { + self.reply("Hello, World!".asComment()); // asComment converts a String to a Cell with a comment +} +``` + +## Send message + +If you need more advanced logic you can use the `send(){:tact}` function and `SendParameters{:tact}` [Struct](/book/structs-and-messages#structs) directly. + +In fact, the previous example with [`.reply(){:tact}`](#send-simple-reply) can be made using the following call to `send(){:tact}` function: + +```tact +receive() { + send(SendParameters{ + // bounce is set to true by default + to: sender(), // sending message back to the sender + value: 0, // don't add Toncoins to the message... + mode: SendRemainingValue | SendIgnoreErrors, // ...except for ones received from the sender due to SendRemainingValue + body: "Hello, World".asComment(), // asComment converts a String to a Cell with a comment + }); +} +``` + +Another example sends a message to the specified [`Address{:tact}`][p] with a `value` of $1$ TON and the `body` of a comment with a [`String{:tact}`][p] `"Hello, World!"{:tact}`: + +```tact +let recipient: Address = ...; +let value: Int = ton("1"); +send(SendParameters{ + // bounce is set to true by default + to: recipient, + value: value, + mode: SendIgnoreErrors, // will send the message despite any errors + body: "Hello, World!".asComment(), +}); +``` + +The [optional flag](/book/message-mode#optional-flags) `SendIgnoreErrors{:tact}` means that even when an error occurs during message sending next messages would be sent anyway. **No error during the sending phase would revert a transaction.** + +## Send typed message + +To send a binary typed message you can use the following code: + +```tact +let recipient: Address = ...; +let value: Int = ton("1"); +send(SendParameters{ + // bounce is set to true by default + to: recipient, + value: value, + mode: SendIgnoreErrors, // don't stop in case of errors + body: SomeMessage{arg1: 123, arg2: 1234}.toCell(), +}); +``` + +## Deploy contract + +To deploy a contract you need to calculate its address and initial state with [`initOf{:tact}`](/book/expressions#initof), then send them in the initialization message: + +```tact +let init: StateInit = initOf SecondContract(arg1, arg2); +let address: Address = contractAddress(init); +let value: Int = ton("1"); +send(SendParameters{ + // bounce is set to true by default + to: address, + value: value, + mode: SendIgnoreErrors, // don't stop in case of errors + code: init.code, + data: init.data, + body: "Hello, World!".asComment(), // not necessary, can be omitted +}); +``` + +## Outbound message processing + +Each transaction on TON Blockchain consists of [multiple phases][phases]. Outbound messages are evaluated in [compute phase][compute], but are **not** sent in that phase. Instead, they're queued in order of appearance for the [action phase][phases], where all actions listed in [compute phase][compute], like outbound messages or [reserve requests](/ref/core-advanced#nativereserve), are executed. + +As all the values are computed in [compute phase][compute], all the fees computed by the end of it, and exceptions do not revert the transaction during [action phase][phases], outbound message sends can fail without bounce due to unsufficient [action fees](https://docs.ton.org/develop/howto/fees-low-level#action-fee) or [forward fees][fwdfee]. + +Consider the following example: + +```tact +// This contract initially has 0 nanoToncoins on the balance +contract FailureIsNothingButAnotherStep { + // And all the funds it gets are obtained from inbound internal messages + receive() { + // 1st outbound message evaluated and queued (but not sent yet) + send(SendParameters{ + to: sender(), + value: ton("0.042"), // plus forward fee due to SendPayGasSeparately + mode: SendIgnoreErrors | SendPayGasSeparately, + }); + + // 2nd outbound message evaluated and queued (but not sent yet, and never will be!) + send(SendParameters{ + to: sender(), + value: 0, + mode: SendRemainingValue | SendIgnoreErrors, + }); + } +} +``` + +There, the second message won't actually be sent: + +* After finishing the [compute phase][compute], the remaining value $\mathrm{R}$ of the contract is computed. + +* During the outbound message processing and assuming that there was enough value provided in the inbound message, the first message leaves $\mathrm{R} - (0.042 + \mathrm{forward\_fees})$ [nanoToncoins](/book/integers#nanotoncoin) on the balance. + +* When the second message is processed, contract tries to send $\mathrm{R}$ [nanoToncoins](/book/integers#nanotoncoin), but fails to do so because there is already a smaller amount left. + +:::note + + Read more about all message sending functions in the Reference: + * [`send(){:tact}`](/ref/core-common#send) + * [`emit(){:tact}`](/ref/core-common#emit) + * [`self.notify(){:tact}`](/ref/core-base#self-notify) + * [`self.reply(){:tact}`](/ref/core-base#self-reply) + * [`self.forward(){:tact}`](/ref/core-base#self-forward) + * [`nativeSendMessage(){:tact}`](/ref/core-advanced#nativesendmessage) + +::: + +[p]: /book/types#primitive-types +[int]: /book/integers +[cell]: /book/cells#cells +[opt]: /book/optionals + +[phases]: https://docs.ton.org/learn/tvm-instructions/tvm-overview#transactions-and-phases +[compute]: https://docs.ton.org/learn/tvm-instructions/tvm-overview#compute-phase +[nano]: /book/integers#nanotoncoin +[fwdfee]: https://docs.ton.org/develop/howto/fees-low-level#forward-fees diff --git a/docs/src/content/docs/book/statements.mdx b/docs/src/content/docs/book/statements.mdx new file mode 100644 index 000000000..2490f3637 --- /dev/null +++ b/docs/src/content/docs/book/statements.mdx @@ -0,0 +1,416 @@ +--- +title: Statements +--- + +The following statements can appear anywhere in the [function](/book/functions) body. + +## `let` statement {#let} + +The `let{:tact}` statement allows local and [block](#block)-scoped variable declaration. + +In Tact, declaring a local variable always requires an initial value. However, the type ascription can be omitted and Tact will try to infer it from the initial value: + +```tact +let value: Int = 123; // full declaration with type and value +let vInferred = 123; // inferred type Int + +let vExplicitCtx: Context = context(); // explicit type Context, a built-in Struct +let vCtx = context(); // inferred type Context +``` + +Note, that initial value of `null{:tact}` can mean both an empty [`map{:tact}`](/book/maps) with arbitrary `K{:tact}` and `V{:tact}` types, and the intentional absence of any other value for the [optional](/book/optionals) type. That's why whenever you're declaring an [optional](/book/optionals) or a [`map{:tact}`](/book/maps), you'll need to explicitly specify the type as it cannot be inferred: + +```tact +let vOptional: Int? = null; // explicit type Int or null +let vOptInt = 42; // implicit type Int +vOptInt = null; // COMPILATION ERROR! + +let vMap: map = emptyMap(); // explicit type map +let vMapWithSerialization: map = emptyMap(); +``` + +Naming a local variable with underscore `_{:tact}` makes its value considered unused and discarded. This is useful when you don't need a return value of some function with side effects, and want to explicitly mark the variable as unused. Note, that such wildcard variable name `_{:tact}` cannot be accessed: + +```tact +let _ = someFunctionWithSideEffects(); // with type inference +let _: map = emptyMap(); // with explicit type + +dump(_); // COMPILATION ERROR! Cannot access _ +``` + +## `return` statement {#return} + +The `return{:tact}` statement ends [function](/book/functions) execution and specifies a value to be returned to the [function](/book/functions) caller. + +```tact +// Simple wrapper over stdlib function now() +fun getTimeFromNow(offset: Int): Int { + return now() + offset; +} +``` + +## Block + +A block statement is used to group zero or more statements. The block is delimited by a pair of braces ("curly braces", `{}{:tact}`) and contains a list of zero or more statements and declarations. + +Some statements, such as [`let{:tact}`](#let) or [`return{:tact}`](#return), must end with a terminating semicolon `;{:tact}`. However, the semicolon of the last statement in the block is optional and may be omitted. + +```tact +{ // <- start of the block + // arbitrary statements: + let value: Int = 2 + 2; + dump(value); +} // <- end of the block + +{ dump(2 + 2) } // a block with only one statement, + // omitted the last and only semicolon + +{ + let nah = 3 * 3 * 3; // a block with two statements, + let yay = nah + 42 // but without the last semicolon +} +``` + +## Expression + +An expression statement is an expression used in a place where a statement is expected. The expression is evaluated and its result is discarded — therefore, it makes sense only for expressions that have side effects, such as executing a function or updating a variable. + +```tact +dump(2 + 2); // stdlib function +``` + +## Assignment + +Assignment statements use an [assignment operator](/book/operators#assignment) (`={:tact}`) or [augmented assignment operators](/book/operators#augmented-assignment) (assignments combined with an operation): + +```tact +let value: Int; // declaration +value = 5; // assignment +value += 5; // augmented assignment (one of the many, see below) +``` + +:::note + + Read more about assignment and augmented assignment in their dedicated section: [assignment operators](/book/operators#assignment). + +::: + +## Branches + +Control the flow of the code. + +### `if...else` {#if-else} + +:::caution + + Curly brackets (code blocks) are required! + +::: + +When executing an `if...else{:tact}` statement, first, the specified condition gets evaluated. If the resulting value is `true{:tact}`, the following statement block gets executed. Otherwise, if the condition evaluates to `false{:tact}`, the optional `else{:tact}` block will be executed. If the `else{:tact}` block is missing, nothing happens and execution continues further. + +Regular `if{:tact}` statement: + +```tact +// condition +// ↓ +if (true) { // consequence, when condition is true + dump(2 + 2); +} +``` + +With `else{:tact}` block: + +```tact +// condition +// ↓ +if (2 + 2 == 4) { + // consequence, when condition is true + dump(true); +} else { + // alternative, when condition is false + dump(false); +} +``` + +With nested `if...else{:tact}`: + +```tact +// condition +// ↓ +if (2 + 2 == 3) { + // consequence, when condition is true + dump("3?"); +// condition2 +// ↓ +} else if (2 + 2 == 4) { + // another consequence, when condition2 is true + dump(true); +} else { + // alternative, when both condition and condition2 are false + dump(false); +} +``` + +:::note + + Tact also has a ternary expression `?:{:tact}`, which is described earlier in the Book: [Ternary](/book/operators#ternary). + +::: + +### `try...catch` {#try-catch} + +The `try...catch{:tact}` statement is comprised of a `try{:tact}` block and an optional `catch{:tact}` block, which receives an [`Int{:tact}`][int] [exit code](/book/exit-codes) as its only argument. The code in the `try{:tact}` block is executed first, and if it fails, the code in the `catch{:tact}` block will be executed and changes made in `try{:tact}` block will be rolled back, if possible. + +:::note + + Note, that some TVM state parameters, such as codepage and gas counters, will not be rolled back. That is, all gas usage in the `try{:tact}` block will be taken into account and the effects of opcodes that change the gas limit will be preserved. + +::: + +Regular `try{:tact}` statement: + +```tact +fun braveAndTrue() { + // Lets try and do something erroneous + try { + nativeThrow(42); // throwing with exit code 42 + } + + // The following will be executed as the erroneous code above was wrapped in a try block + dump(42); +} +``` + +With `catch (e){:tact}` block: + +```tact +fun niceCatch() { + // Lets try and do something erroneous + try { + nativeThrow(42); // throwing with exit code 42 + } catch (err) { + dump(err); // this will dump the exit code caught, which is 42 + } +} +``` + +With nested `try...catch{:tact}`: + +```tact +try { + // Preparing an x equal to 0, in such a way that Tact compiler won't realize it (yet!) + let xs: Slice = beginCell().storeUint(0, 1).endCell().beginParse(); + let x: Int = xs.loadUint(1); // 0 + + try { + throw(101); // 1. throws with exit code 101 + } catch (err) { // 2. catches the error and captures its exit code (101) as err + return err / x; // 3. divides err by x, which is zero, throwing with exit code 4 + } + +} catch (err) { // 4. catches the new error and captures its exit code (4) as err + // ^^^ this works without name collisions because the previous err + // has a different scope and is only visible inside the previous catch block + + dump(err); // 5. dumps the last caught exit code (4) +} +``` + +Note, that similar to [`let{:tact}` statement](#let), captured [exit code](/book/exit-codes) in the `catch (){:tact}` clause can be discarded by specifying an underscore `_{:tact}` in its place: + +```tact +try { + throw(42); +} catch (_) { + dump("I don't know the exit code anymore"); +} +``` + +:::note + + Read more about exit codes on the dedicated page: [Exit codes in the Book](/book/exit-codes). + +::: + +## Loops + +Conditionally repeat certain blocks of code multiple times. + +### `repeat` {#repeat-loop} + +The `repeat{:tact}` loop executes a block of code a specified number of times. The number of repetitions should be given as a positive $32$-bit [`Int{:tact}`][int] in the inclusive range from $1$ to $2^{31} - 1$. If the value is greater, an error with the [exit code 5](/book/exit-codes#5), `Integer out of the expected range` would be thrown. + +If the specified number of repetitions is equal to $0$ or any negative number in the inclusive range $-2^{256}$ to $-1$, it is ignored and the code block is not executed at all. + +```tact +let twoPow: Int = 1; + +// Repeat exactly 10 times +repeat (10) { + twoPow *= 2; +} + +// Skipped +repeat (-1) { + twoPow *= 3333; +} + +twoPow; // 1024 +``` + +### `while` {#while-loop} + +The `while{:tact}` loop continues executing the block of code as long as the given condition is `true{:tact}`. + +In the following example, the value of `x` is decremented by $1$ on each iteration, so the loop will run $10$ times: + +```tact +let x: Int = 10; +while (x > 0) { + x -= 1; +} +``` + +### `do...until` {#do-until-loop} + +The `do...until{:tact}` loop is a post-test loop that executes the block of code at least once, and then continues to execute it until the given condition becomes `true{:tact}`. + +In the following example, the value of `x` is decremented by $1$ on each iteration, so the loop will run $10$ times: + +```tact +let x: Int = 10; +do { + x -= 1; // executes this code block at least once +} until (x <= 0); +``` + +### `foreach` {#foreach-loop} + +The `foreach{:tact}` loop operates on key-value pairs (entries) of [`map{:tact}`](/book/maps) type in sequential order: from the smallest keys of the map to the biggest ones. + +This loop executes a block of code for each entry in the given map, capturing the key and value on each iteration. This is handy when you don't know in advance how many items there is in the map or don't want to explicitly look for each of the entry using [`.get(){:tact}`](/book/maps#get) [method](/book/functions#extension-function) of maps. + +Note, that the names of captured key and value pair on each iteration are arbitrary and can be any valid Tact identifier, provided that they're new to the current scope. The most common options are: `k` and `v`, or `key` and `value`. + +In the following example, map `cells` has $4$ entries, so the loop will run $4$ times: + +```tact +// Empty map +let cells: map = emptyMap(); + +// Setting four entries +cells.set(1, beginCell().storeUint(100, 16).endCell()); +cells.set(2, beginCell().storeUint(200, 16).endCell()); +cells.set(3, beginCell().storeUint(300, 16).endCell()); +cells.set(4, beginCell().storeUint(400, 16).endCell()); + +// A variable for summing up the values +let sum: Int = 0; + +// For each key and value pair in cells map, do: +foreach (key, value in cells) { // or just k, v + let s: Slice = value.beginParse(); // convert Cell to Slice + sum += s.loadUint(16); // sum the Slice values +} +dump(sum); // 1000 +``` + +It's also possible to iterate over a map in contract storage, and over maps as members of instances of [Struct](/book/structs-and-messages#structs) or [Message](/book/structs-and-messages#messages) types: + +```tact +import "@stdlib/deploy"; + +struct Fizz { oh_my: map } +message Buzz { oh_my: map } + +contract Iterated { + oh_my: map; + + receive("call to iterate!") { + let oh_my: map = emptyMap(); + oh_my.set(0, 42); + oh_my.set(1, 27); + + self.oh_my = oh_my; // assigning local map to the storage one + let fizz = Fizz{ oh_my }; // field punning + let buzz = Buzz{ oh_my }; // field punning + + // Iterating over map in contract storage + foreach (key, value in self.oh_my) { + // ... + } + + // Iterating over map member of a Struct Fizz instance + foreach (key, value in fizz.oh_my) { + // ... + } + + // Iterating over map member of a Message Buzz instance + foreach (key, value in buzz.oh_my) { + // ... + } + } +} +``` + +Note, that similar to [`let{:tact}` statement](#let), either of captured key or value (or both) can be discarded by specifying an underscore `_{:tact}` in their place: + +```tact +// Empty map +let quartiles: map = emptyMap(); + +// Setting some entries +quartiles.set(1, 25); +quartiles.set(2, 50); +quartiles.set(3, 75); + +// Discarding captured keys +// without modifying them in the map itself +foreach (_, value in quartiles) {} + +// Discarding captured values +// without modifying them in the map itself +foreach (key, _ in quartiles) {} + +// Discarding both keys and values +// without modifying them in the map itself +foreach (_, _ in quartiles) { + // Can't access via _, but can do desired operations + // n times, where n is the current length of the map +} +``` + +:::caution + + Note, that at the moment `foreach{:tact}` works only with explicitly provided map identifiers and nested identifier constructions, like `foo.bar.targetMap{:tact}` or `self.baz.targetMap{:tact}`. That is, returning a map from a function and trying to iterate over its entries won't work: + + ```tact + foreach (k, v in emptyMap()) { + // ^ this will give the following error message: + // foreach is only allowed over maps that are path expressions, + // i.e. identifiers, or sequences of direct contract/struct/message accesses, + // like "self.foo" or "self.structure.field" + } + ``` + + Trying to iterate over a map member of a [Struct](/book/structs-and-messages#structs) returned from a function also won't work, because function call is an expression and not an identifier nor a nested identifier access: + + ```tact + foreach (k, v in genCoolStruct().map) { + // ^ this will give the following error message: + // foreach is only allowed over maps that are path expressions, + // i.e. identifiers, or sequences of direct contract/struct/message accesses, + // like "self.foo" or "self.structure.field" + } + ``` + +::: + +:::note + + For additional loop examples see: [Loops in Tact-By-Example](https://tact-by-example.org/04-loops). + +::: + +[int]: /book/integers diff --git a/docs/src/content/docs/book/structs-and-messages.mdx b/docs/src/content/docs/book/structs-and-messages.mdx new file mode 100644 index 000000000..5588c6eea --- /dev/null +++ b/docs/src/content/docs/book/structs-and-messages.mdx @@ -0,0 +1,302 @@ +--- +title: Structs and Messages +--- + +Tact supports a number of [primitive data types](/book/types#primitive-types) that are tailored for smart contract use. However, using individual means of storage often becomes cumbersome, so there are [Structs](#structs) and [Messages](#messages) which allow combining types together. + +:::caution + + **Warning**: Currently circular types are **not** possible. This means that Struct/Message **A** can't have a field of a Struct/Message **B** that has a field of the Struct/Message **A**. + + Therefore, the following code **won't** compile: + + ```tact + struct A { + circularFieldA: B; + } + + struct B { + impossibleFieldB: A; + } + ``` + +::: + +## Structs + +Structs can define complex data types that contain multiple fields of different types. They can also be nested. + +```tact +struct Point { + x: Int as int64; + y: Int as int64; +} + +struct Line { + start: Point; + end: Point; +} +``` + +Structs can also contain default fields and define fields of [optional types](/book/optionals). This can be useful if you have a lot of fields, but don't want to keep having to specify common values for them in [new instances](#instantiate). + +```tact +struct Params { + name: String = "Satoshi"; // default value + + age: Int?; // field with an optional type Int? + // and default value of null + + point: Point; // nested Structs +} +``` + +Structs are also useful as return values from getters or other internal functions. They effectively allow a single getter to return multiple return values. + +```tact +contract StructsShowcase { + params: Params; // Struct as a contract's persistent state variable + + init() { + self.params = Params{ + point: Point{ + x: 4, + y: 2, + }, + }; + } + + get fun params(): Params { + return self.params; + } +} +``` + +Note, that the last semicolon `;` in Struct declaration is optional and may be omitted: + +```tact +struct Mad { ness: Bool } + +struct MoviesToWatch { + wolverine: String; + redFunnyGuy: String +} +``` + +The order of fields matters, as it corresponds to the resulting memory layout in [TL-B schemas](https://docs.ton.org/develop/data-formats/tl-b-language). However, unlike some languages with manual memory management, Tact does not have any padding between fields. + +## Messages + +Messages can hold [Structs](#structs) in them: + +```tact +struct Point { + x: Int; + y: Int; +} + +message Add { + point: Point; // holds a struct Point +} +``` + +Messages are almost the same thing as [Structs](#structs) with the only difference that Messages have a 32-bit integer header in their serialization containing their unique numeric id, commonly referred to as an _opcode_ (operation code). This allows Messages to be used with [receivers](/book/receive) since the contract can tell different types of messages apart based on this id. + +Tact automatically generates those unique ids (opcodes) for every received Message, but this can be manually overwritten: + +```tact +// This Message overwrites its unique id with 0x7362d09c +message(0x7362d09c) TokenNotification { + forwardPayload: Slice as remaining; +} +``` + +This is useful for cases where you want to handle certain opcodes of a given smart contract, such as [Jetton standard](https://github.com/ton-blockchain/TEPs/blob/master/text/0074-jettons-standard.md). The short-list of opcodes this contract is able to process is [given here in FunC](https://github.com/ton-blockchain/token-contract/blob/main/ft/op-codes.fc). They serve as an interface to the smart contract. + +:::note + + For more in-depth information on this see:\ + [Convert received messages to `op` operations](/book/func#convert-received-messages-to-op-operations)\ + [Internal message body layout in TON Docs](https://docs.ton.org/develop/smart-contracts/guidelines/internal-messages#internal-message-body)\ + [Messages of the Jetton implementation in Tact](https://github.com/howardpen9/jetton-implementation-in-tact/blob/9eee917877a92af218002874a9f2bd3f9c619229/sources/messages.tact)\ + [Jetton Standard in Tact on Tact-by-Example](https://tact-by-example.org/07-jetton-standard) + +::: + +## Operations + +### Instantiate + +Creation of [Struct](#structs) and [Message](#messages) instances resembles [function calls](/book/expressions#static-function-call), but instead of paretheses `(){:tact}` one needs to specify arguments in braces `{}{:tact}` (curly brackets): + +```tact +struct StA { + field1: Int; + field2: Int; +} + +message MsgB { + field1: String; + field2: String; +} + +fun example() { + // Instance of a Struct StA + StA{ + field1: 42, + field2: 68 + 1, // trailing comma is allowed + }; + + // Instance of a Message MsgB + MsgB{ + field1: "May the 4th", + field2: "be with you!", // trailing comma is allowed + }; +} +``` + +When the name of a variable or constant assigned to a field coincides with the name of such field, Tact provides a handy syntactic shortcut sometimes called field punning. With it, you don't have to type more than it's necessary: + +```tact +struct PopQuiz { + vogonsCount: Int; + nicestNumber: Int; +} + +fun example() { + // Let's introduce a couple of variables + let vogonsCount: Int = 42; + let nicestNumber: Int = 68 + 1; + + // You may instantiate the Struct as usual and assign variables to fields, + // but that is a bit repetitive and tedious at times + PopQuiz{ vogonsCount: vogonsCount, nicestNumber: nicestNumber }; + + // Let's use field punning and type less, + // because our variable names happen to be the same as field names + PopQuiz{ + vogonsCount, + nicestNumber, // trailing comma is allowed here too! + }; +} +``` + +:::note + + Because instantiation is an expression in Tact, it's also described on the related page: [Instantiation expression](/book/expressions#instantiation). + +::: + +### Convert to a `Cell`, `.toCell()` {#tocell} + +It's possible to convert an arbitrary [Struct](#structs) or [Message](#messages) to the [`Cell{:tact}`][cell] type by using the `.toCell(){:tact}` [extension function](/book/functions#extension-function): + +```tact +struct Big { + f1: Int; + f2: Int; + f3: Int; + f4: Int; + f5: Int; + f6: Int; +} + +fun conversionFun() { + dump(Big{ + f1: 10000000000, f2: 10000000000, f3: 10000000000, + f4: 10000000000, f5: 10000000000, f6: 10000000000, + }.toCell()); // x{...cell with references...} +} +``` + +:::note + + See those extension functions in the Reference:\ + [`Struct.toCell(){:tact}`](/ref/core-cells#structtocell)\ + [`Message.toCell(){:tact}`](/ref/core-cells#messagetocell) + +::: + +### Obtain from a `Cell` or `Slice`, `.fromCell()` and `.fromSlice()` {#fromcellslice} + +Instead of manually parsing a [`Cell{:tact}`][cell] or [`Slice{:tact}`][slice] via a series of relevant `.loadSomething(){:tact}` function calls, one can use `.fromCell(){:tact}` and `.fromSlice(){:tact}` [extension functions](/book/functions#extension-function) for converting the provided [`Cell{:tact}`][cell] or [`Slice{:tact}`][slice] into the needed [Struct](#structs) or [Message](#messages). + +Those extension functions only attempt to parse a [`Cell{:tact}`][cell] or [`Slice{:tact}`][slice] according to the structure of your [Struct](#structs) or [Message](#messages). In case layouts don't match, various exceptions may be thrown — make sure to wrap your code in [`try...catch{:tact}`](/book/statements#try-catch) blocks to prevent unexpected results. + +```tact +struct Fizz { foo: Int } +message(100) Buzz { bar: Int } + +fun constructThenParse() { + let fizzCell = Fizz{foo: 42}.toCell(); + let buzzCell = Buzz{bar: 27}.toCell(); + + let parsedFizz: Fizz = Fizz.fromCell(fizzCell); + let parsedBuzz: Buzz = Buzz.fromCell(buzzCell); +} +``` + +:::note + + See those extension functions in the Reference:\ + [`Struct.fromCell(){:tact}`][st-fc]\ + [`Struct.fromSlice(){:tact}`][st-fs]\ + [`Message.fromCell(){:tact}`][msg-fc]\ + [`Message.fromSlice(){:tact}`][msg-fs] + +::: + +### Conversion laws + +Whenever one converts between [`Cell{:tact}`][cell]/[`Slice{:tact}`][slice] and [Struct](#structs)/[Message](#messages) via `.toCell(){:tact}` and `.fromCell(){:tact}` functions, the following laws hold: + +* For any instance of type [Struct](#structs)/[Message](#messages), calling `.toCell(){:tact}` on it, then applying `Struct.fromCell(){:tact}` (or `Message.fromCell(){:tact}`) to the result gives back the copy of the original instance: + +```tact {8-9,13-14} +struct ArbitraryStruct {} +message(0x2A) ArbitraryMessage {} + +fun lawOne() { + let structInst = ArbitraryStruct{}; + let messageInst = ArbitraryMessage{}; + + ArbitraryStruct.fromCell(structInst.toCell()); // = structInst + ArbitraryMessage.fromCell(messageInst.toCell()); // = messageInst + + // Same goes for Slices, with .toCell().asSlice() and .fromSlice() + + ArbitraryStruct.fromSlice(structInst.toCell().asSlice()); // = structInst + ArbitraryMessage.fromSlice(messageInst.toCell().asSlice()); // = messageInst +} +``` + +* For any [`Cell{:tact}`][cell] with the same [TL-B](https://docs.ton.org/develop/data-formats/tl-b-language) layout as a given [Struct](#structs)/[Message](#messages), calling `Struct.fromCell(){:tact}` (or `Message.fromCell(){:tact}`) on it, and then converting the result to a [`Cell{:tact}`][cell] via `.toCell(){:tact}` would give the copy of the original [`Cell{:tact}`][cell]: + +```tact {9-10,15-16} +struct ArbitraryStruct { val: Int as uint32 } +message(0x2A) ArbitraryMessage {} + +fun lawTwo() { + // Using 32 bits to store 42 just so this cellInst can be + // re-used for working with both ArbitraryStruct and ArbitraryMessage + let cellInst = beginCell().storeUint(42, 32).endCell(); + + ArbitraryStruct.fromCell(cellInst).toCell(); // = cellInst + ArbitraryMessage.fromCell(cellInst).toCell(); // = cellInst + + // Same goes for Slices, with .fromSlice() and .toCell().asSlice() + let sliceInst = cellInst.asSlice(); + + ArbitraryStruct.fromSlice(sliceInst).toCell().asSlice(); // = sliceInst + ArbitraryMessage.fromSlice(sliceInst).toCell().asSlice(); // = sliceInst +} +``` + +[st-fc]: /ref/core-cells#structfromcell +[st-fs]: /ref/core-cells#structfromslice +[msg-fc]: /ref/core-cells#messagefromcell +[msg-fs]: /ref/core-cells#messagefromslice + +[p]: /book/types#primitive-types +[cell]: /book/cells#cells +[slice]: /book/cells#slices diff --git a/docs/src/content/docs/book/types.mdx b/docs/src/content/docs/book/types.mdx new file mode 100644 index 000000000..fcba5f4d2 --- /dev/null +++ b/docs/src/content/docs/book/types.mdx @@ -0,0 +1,176 @@ +--- +title: Type system overview +--- + +Every variable, item, and value in Tact programs has a type. They can be: + +* One of the [primitive types](#primitive-types) +* or [composite types](#composite-types) + +Additionally, many of those types [can be made nullable](#optionals). + +## Primitive types + +Tact supports a number of primitive data types that are tailored for smart contract use: + +* [`Int{:tact}`](/book/integers) — all numbers in Tact are $257$-bit signed integers, but [smaller representations](/book/integers#serialization) can be used to reduce storage costs. +* [`Bool{:tact}`](#booleans) — classical boolean with `true{:tact}` and `false{:tact}` values. +* `Address{:tact}` — standard [smart contract address](https://docs.ton.org/learn/overviews/addresses#address-of-smart-contract) in TON Blockchain. +* [`Cell{:tact}`](/book/cells#cells), [`Builder{:tact}`](/book/cells#builders), [`Slice{:tact}`](/book/cells#slices) — low-level primitives of [TVM][tvm]. +* `String{:tact}` — immutable text strings. +* `StringBuilder{:tact}` — helper type that allows you to concatenate strings in a gas-efficient way. + +[tvm]: https://docs.ton.org/learn/tvm-instructions/tvm-overview + +### Booleans {#booleans} + +The primitive type `Bool{:tact}` is the classical boolean type, which can hold only the two values: `true{:tact}` and `false{:tact}`. It's convenient for boolean and logical operations, as well as for storing flags. + +There are no implicit type conversions in Tact, so addition ([`+{:tact}`](/book/operators#binary-add)) of two boolean values isn't possible. Hovewer, many comparison [operators](/book/operators) are available, such as: + +* `&&{:tact}` for [logical AND](/book/operators#binary-logical-and), +* `||{:tact}` for [logical OR](/book/operators#binary-logical-or), +* `!{:tact}` for [logical inversion](/book/operators#unary-inverse), +* `=={:tact}` and `!={:tact}` for checking [equality](/book/operators#binary-equality), +* and `!!{:tact}` for [non-null assertion](/book/optionals). + +Persisting bools to state is very space-efficient, as they only take 1-bit. Storing 1000 bools in state [costs](https://ton.org/docs/develop/smart-contracts/fees#how-to-calculate-fees) about $0.00072$ TON per year. + +## Composite types + +Using individual means of storage often becomes cumbersome, so there are ways to combine multiple [primitive types](#primitive-types) together to create composite types: + +* [Maps](#maps) — associations of keys with values. +* [Structs and Messages](#structs-and-messages) — data structures with typed fields. +* [Optionals](#optionals) — `null{:tact}` values for variables or fields of [Structs and Messages](#structs-and-messages). + +In addition to the composite types above, Tact provides a special type constructor [`bounced{:tact}`](/book/bounced), which can only be specified in [bounced message receivers](/book/bounced). + +Note, while [contracts](#contracts) and [traits](#traits) are also considered a part of the Tacts type system, one can't pass them around like [Structs and Messages](#structs-and-messages). Instead, it's possible to obtain the initial state of the given contract by using the [`initOf{:tact}`](/book/expressions#initof) expression. + +### Maps + +The type [`map{:tact}`][maps] is used as a way to associate keys of type `K{:tact}` with corresponding values of type `V{:tact}`. + +Example of a [`map{:tact}`][maps]: + +```tact +let mapExample: map = emptyMap(); // empty map with Int keys and values +``` + +Learn more about them on a dedicated page: [Maps][maps]. + +[maps]: /book/maps + +### Structs and Messages + +[Structs][structs] and [Messages][messages] are two main ways of combining multiple [primitive types](#primitive-types) into a composite one. + +Example of a [Struct][structs]: + +```tact +struct Point { + x: Int; + y: Int; +} +``` + +Example of a [Message][messages]: + +```tact +// Custom numeric id of the Message +message(0x11111111) SetValue { + key: Int; + value: Int?; // Optional, Int or null + coins: Int as coins; // Serialization into TL-B types +} +``` + +Learn more about them on a dedicated page: [Structs and Messages][s-n-m]. + +[s-n-m]: /book/structs-and-messages +[structs]: /book/structs-and-messages#structs +[messages]: /book/structs-and-messages#messages + +### Optionals + +All [primitive types](#primitive-types), as well as [Structs and Messages](#structs-and-messages) could be nullable and hold a special `null{:tact}` value. + +Example of an [optional][optionals]: + +```tact +let opt: Int? = null; // Int or null, with explicitly assigned null +``` + +Learn more about them on a dedicated page: [Optionals][optionals]. + +[optionals]: /book/optionals + +### Contracts + +[Contracts](/book/contracts) in Tact serve as the main entrypoints of smart contracts of TON blockchain. They hold all [functions](/book/functions), [getters](/book/functions#getter-functions), and [receivers](/book/functions#receiver-functions) of a TON contract, and much more. + +Example of a [contract](/book/contracts): + +```tact +contract HelloWorld { + // Persistent state variable + counter: Int; + + // Constructor function init(), where all the variables are initialized + init() { + self.counter = 0; + } + + // Internal message receiver, which responds to a string message "increment" + receive("increment") { + self.counter += 1; + } + + // Getter function with return type Int + get fun counter(): Int { + return self.counter; + } +} +``` + +Read more about them on the dedicated page: [Contracts](/book/contracts). + +### Traits + +Tact doesn't support classical class inheritance, but instead introduces the concept of _traits_, which can be viewed as abstract contracts (like abstract classes in popular object-oriented languages). They have the same structure as [contracts](#contracts), but can't [initialize persistent state variables](/book/contracts#init-function). + +A trait can also let the contract inheriting it to override the behavior of its [functions](/book/functions#virtual-and-abstract-functions) and the value of its [constants](/book/constants#virtual-and-abstract-constants). + +Example of a trait [`Ownable{:tact}`](/ref/stdlib-ownable#ownable) from [`@stdlib/ownable`](/ref/stdlib-ownable): + +```tact +trait Ownable { + // Persistent state variable, which cannot be initialized in the trait + owner: Address; + + // Internal function + fun requireOwner() { + nativeThrowUnless(132, context().sender == self.owner); + } + + // Getter function with return type Address + get fun owner(): Address { + return self.owner; + } +} +``` + +And the [contract](#contracts) that uses trait [`Ownable{:tact}`](/ref/stdlib-ownable#ownable): + +```tact +contract Treasure with Ownable { + // Persistent state variable, which MUST be defined in the contract + owner: Address; + + // Constructor function init(), where all the variables are initialized + init(owner: Address) { + self.owner = owner; + } +} +``` diff --git a/docs/src/content/docs/book/upgrades.mdx b/docs/src/content/docs/book/upgrades.mdx new file mode 100644 index 000000000..0280d3a5a --- /dev/null +++ b/docs/src/content/docs/book/upgrades.mdx @@ -0,0 +1,5 @@ +--- +title: Contracts upgrades +--- + +Tact currently doesn't allow contract upgrades since Tact contracts have a more convoluted nature than the ones in FunC. It is theoretically possible, but the required tools are not here. diff --git a/docs/src/content/docs/cookbook/access.mdx b/docs/src/content/docs/cookbook/access.mdx new file mode 100644 index 000000000..5a641c698 --- /dev/null +++ b/docs/src/content/docs/cookbook/access.mdx @@ -0,0 +1,52 @@ +--- +title: Access control +--- + +This page lists common examples of working with privileges, ownership and access control. + +## How to check sender privileges using Ownable trait + +```tact +// Ownable has to be imported from stdlib, as well as Deployable, for convenience: +import "@stdlib/ownable"; +import "@stdlib/deploy"; + +message FooBarMsg { + newVal: Int as uint32; +} + +// Ownable trait can limit certain actions to the owner only +contract SenderChecker with Deployable, Ownable { + // Persistent state variables + owner: Address; // Ownable trait requires you to add this exact state variable + val: Int as uint32; // some value + + init() { + // we can initialize owner to any value we want, the deployer in this case: + self.owner = sender(); + self.val = 0; + } + + receive("inc") { + self.requireOwner(); // throws exit code 132 if the sender isn't an owner + self.val += 1; + } + + receive(msg: FooBarMsg) { + self.requireOwner(); // throws exit code 132 if the sender isn't an owner + self.val = msg.newVal; + } +} +``` + +:::note[Useful links:] + + [`trait Ownable{:tact}` in Core library](/ref/stdlib-ownable#ownable) + +::: + +:::tip[Hey there!] + + Didn't find your favorite example of access control? Have cool implementations in mind? [Contributions are welcome!](https://github.com/tact-lang/tact/issues) + +::: diff --git a/docs/src/content/docs/cookbook/algo.mdx b/docs/src/content/docs/cookbook/algo.mdx new file mode 100644 index 000000000..9b3be847c --- /dev/null +++ b/docs/src/content/docs/cookbook/algo.mdx @@ -0,0 +1,11 @@ +--- +title: Algorithms +--- + +Algorithm is a finite sequence of rigorous instructions, typically used to solve a class of specific problems or to perform a computation. + +:::danger[Not implemented] + + This page is a stub. [Contributions are welcome!](https://github.com/tact-lang/tact/issues) + +::: diff --git a/docs/src/content/docs/cookbook/data-structures.mdx b/docs/src/content/docs/cookbook/data-structures.mdx new file mode 100644 index 000000000..1b48beb90 --- /dev/null +++ b/docs/src/content/docs/cookbook/data-structures.mdx @@ -0,0 +1,377 @@ +--- +title: Data structures +--- + +Data structures are data organization, management, and storage formats that are usually chosen for efficient access to data. More precisely, a data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data. + +This page lists a handy collection of data structures implemented in Tact for your day-to-day needs and beyond. + +All of the data structures listed here are made using the built-in [`map{:tact}`][map] type. For the description and basic usage of maps see the [dedicated page in the Book][map]. + +## Array + +An [array](https://en.wikipedia.org/wiki/Array_(data_structure)) is a data structure consisting of a continuous block of memory, which represents a collection of elements of same memory size, each identified by at least one array key or _index_. + +Following example emulates an array using a [`map{:tact}`][map] wrapped in a [Struct](/book/structs-and-messages#structs), where `V{:tact}` can be any of the [allowed value types](/book/maps#allowed-types) of the map: + +```tact +import "@stdlib/deploy"; // for Deployable trait + +struct Array { + m: map; // array of Int values as a map of Ints to Ints, + // with serialization of its keys to uint16 to save space + length: Int = 0; // length of the array, defaults to 0 +} + +// Compile-time constant upper bound for our map representing an array. +const MaxArraySize: Int = 5_000; // 5,000 entries max, to stay reasonably far from limits + +// Extension mutation function for adding new entries to the end of the array +extends mutates fun append(self: Array, item: Int) { + require(self.length + 1 <= MaxArraySize, "No space in the array left for new items!"); + + self.map.set(self.length, item); // set the entry (key-value pair) + self.length += 1; // increase the length field +} + +// Extension mutation function for inserting new entries at the given index +extends mutates fun insert(self: Array, item: Int, idx: Int) { + require(self.length + 1 <= MaxArraySize, "No space in the array left for new items!"); + require(idx >= 0, "Index of the item cannot be negative!"); + require(idx < self.length, "Index is out of array bounds!"); + + // Move all items from idx to the right + let i: Int = self.length; // not a typo, as we need to start from the non-existing place + while (i > idx) { + // Note, that we use !! operator as we know for sure that the value would be there + self.map.set(i, self.map.get(i - 1)!!); + i -= 1; + } + + // And put the new item in + self.map.set(idx, item); // set the entry (key-value pair) + self.length += 1; // increase the length field +} + +// Extension function for getting the value at the given index +extends fun getIdx(self: Array, idx: Int): Int { + require(self.length > 0, "No items in the array!"); + require(idx >= 0, "Index of the item cannot be negative!"); + require(idx < self.length, "Index is out of array bounds!"); + + // Note, that we use !! operator as we know for sure that the value would be there + return self.map.get(idx)!!; +} + +// Extension function for returning the last value +extends fun getLast(self: Array): Int { + require(self.length > 0, "No items in the array!"); + + // Note, that we use !! operator as we know for sure that the value would be there + return self.map.get(self.length - 1)!!; +} + +// Extension mutation function for deleting and entry at the given index and returning its value +extends mutates fun deleteIdx(self: Array, idx: Int): Int { + require(self.length > 0, "No items in the array to delete!"); + require(idx >= 0, "Index of the item cannot be negative!"); + require(idx < self.length, "Index is out of array bounds!"); + + // Remember the value, which is going to be deleted + let memorized: Int = self.map.get(idx)!!; + + // Move all items from idx and including to the left + let i: Int = idx; + while (i + 1 < self.length) { + // Note, that we use !! operator as we know for sure that the value would be there + self.map.set(i, self.map.get(i + 1)!!); + i += 1; + } + + self.map.set(self.length - 1, null); // delete the last entry + self.length -= 1; // decrease the length field + + return memorized; +} + +// Extension mutation function for deleting the last entry and returning its value +extends fun deleteLast(self: Array): Int { + require(self.length > 0, "No items in the array!"); + + // Note, that we use !! operator as we know for sure that the value would be there + let lastItem: Int = self.map.get(self.length - 1)!!; + self.map.set(self.length - 1, null); // delete the entry + self.length -= 1; // decrease the length field + + return lastItem; +} + +// Extension function for deleting all items in the Array +extends mutates fun deleteAll(self: Array) { + self.map = emptyMap(); + self.length = 0; +} + +// Global static function for creating an empty Array +fun emptyArray(): Array { + return Array{m: emptyMap(), length: 0}; // length defaults to 0 +} + +// Contract, with emulating an Array using the map +contract MapAsArray with Deployable { + // Persistent state variables + array: Array; + + // Constructor (initialization) function of the contract + init() { + self.array = emptyArray(); + } + + // Internal message receiver, which responds to a String message "append" + receive("append") { + // Add a new item + self.array.append(42); + } + + // Internal message receiver, which responds to a String message "delete_5h" + receive("delete_5th") { + // Remove the 5th item if it exists and reply back with its value, or raise an error + self.reply(self.array.deleteIdx(4).toCoinsString().asComment()); // index offset 0 + 4 gives the 5th item + } + + // Internal message receiver, which responds to a String message "del_last" + receive("del_last") { + // Remove the last item and reply back with its value, or raise an error + self.reply(self.array.deleteLast().toCoinsString().asComment()); + } + + // Internal message receiver, which responds to a String message "get_last" + receive("get_last") { + // Reply back with the latest item in the array if it exists, or raise an error + self.reply(self.array.getLast().toCoinsString().asComment()); + } + + // Internal message receiver, which responds to a String message "delete_all" + receive("delete_all") { + self.array.deleteAll(); + } +} +``` + +## Stack + +A [stack](https://en.wikipedia.org/wiki/Stack_(abstract_data_type)) is a data structure consisting of a collection of elements with two main operations: + +* push, which adds an element to the end of the collection +* pop, which removes the most recently added element + +Following example emulates a stack using a [`map{:tact}`][map] wrapped in a [Struct](/book/structs-and-messages#structs), where `V{:tact}` can be any of the [allowed value types](/book/maps#allowed-types) of the map: + +```tact +import "@stdlib/deploy"; // for Deployable trait + +struct Stack { + m: map; // stack of Int values as a map of Ints to Ints, + // with serialization of its keys to uint16 to save space + length: Int = 0; // length of the stack, defaults to 0 +} + +// Compile-time constant upper bound for our map representing an stack. +const MaxStackSize: Int = 5_000; // 5,000 entries max, to stay reasonably far from limits + +// Extension mutation function for adding new entries to the end of the stack +extends mutates fun push(self: Stack, item: Int) { + require(self.length + 1 <= MaxStackSize, "No space in the stack left for new items!"); + + self.map.set(self.length, item); // set the entry (key-value pair) + self.length += 1; // increase the length field +} + +// Extension mutation function for deleting the last entry and returning its value +extends mutates fun pop(self: Stack): Int { + require(self.length > 0, "No items in the stack to delete!"); + + // Note, that we use !! operator as we know for sure that the value would be there + let lastItem: Int = self.map.get(self.length - 1)!!; + self.map.set(self.length - 1, null); // delete the entry + self.length -= 1; // decrease the length field + + return lastItem; +} + +// Extension function for returning the last value +extends fun peek(self: Stack): Int { + require(self.length > 0, "No items in the stack!"); + + // Note, that we use !! operator as we know for sure that the value would be there + return self.map.get(self.length - 1)!!; +} + +// Extension function for deleting all items in the Stack +extends mutates fun deleteAll(self: Stack) { + self.map = emptyMap(); + self.length = 0; +} + +// Global static function for creating an empty Stack +fun emptyStack(): Stack { + return Stack{m: emptyMap(), length: 0}; // length defaults to 0 +} + +contract MapAsStack with Deployable { + // Persistent state variables + stack: Stack; // our stack, which uses the map + + // Constructor (initialization) function of the contract + init() { + self.stack = emptyStack(); + } + + // Internal message receiver, which responds to a String message "push" + receive("push") { + // Add a new item + self.stack.push(42); + } + + // Internal message receiver, which responds to a String message "pop" + receive("pop") { + // Remove the last item and reply with it + self.reply(self.stack.pop().toCoinsString().asComment()); + } + + // Internal message receiver, which responds to a String message "peek" + receive("peek") { + // Reply back with the latest item in the map if it exists, or raise an error + self.reply(self.stack.peek().toCoinsString().asComment()); + } + + // Internal message receiver, which responds to a String message "delete_all" + receive("delete_all") { + self.stack.deleteAll(); + } + + // Getter function for obtaining the stack + get fun map(): map { + return self.stack.map; + } + + // Getter function for obtaining the current length of the stack + get fun length(): Int { + return self.stack.length; + } +} +``` + +## Circular buffer + +A [circular buffer](https://en.wikipedia.org/wiki/Circular_buffer) (circular queue, cyclic buffer or ring buffer) is a data structure, which uses a single, fixed-size [buffer](https://en.wikipedia.org/wiki/Data_buffer) as it were connected end-to-end. + +Following example emulates a circular buffer using a [`map{:tact}`][map] wrapped in a [Struct](/book/structs-and-messages#structs), where `V{:tact}` can be any of the [allowed value types](/book/maps#allowed-types) of the map: + +```tact +import "@stdlib/deploy"; // for Deployable trait + +struct CircularBuffer { + m: map; // circular buffer of Int values as a map of Ints to Ints, + // with serialization of its keys to uint8 to save space + length: Int = 0; // length of the circular buffer, defaults to 0 + start: Int = 0; // current index into the circular buffer, defaults to 0 +} + +// Compile-time constant upper bound for our map representing a circular buffer. +const MaxCircularBufferSize: Int = 5; + +// Extension mutation function for putting new items to the circular buffer +extends mutates fun put(self: CircularBuffer, item: Int) { + if (self.length < MaxCircularBufferSize) { + self.map.set(self.length, item); // store the item + self.length += 1; // increase the length field + } else { + self.map.set(self.start, item); // store the item, overriding previous entry + self.start = (self.start + 1) % MaxCircularBufferSize; // update starting position + } +} + +// Extension mutation function for getting an item from the circular buffer +extends mutates fun getIdx(self: CircularBuffer, idx: Int): Int { + require(self.length > 0, "No items in the circular buffer!"); + require(idx >= 0, "Index of the item cannot be negative!"); + + if (self.length < MaxCircularBufferSize) { + // Note, that we use !! operator as we know for sure that the value would be there + return self.map.get(idx % self.length)!!; + } + + // Return the value rotating around the circular buffer, also guaranteed to be there + return self.map.get((self.start + idx) % MaxCircularBufferSize)!!; +} + +// Extension function for iterating over all items in the circular buffer and dumping them to the console +extends fun printAll(self: CircularBuffer) { + let i: Int = self.start; + repeat (self.length) { + dump(self.map.get(i)!!); // !! tells the compiler this can't be null + i = (i + 1) % MaxCircularBufferSize; + } +} + +// Extension function for deleting all items in the CircularBuffer +extends mutates fun deleteAll(self: CircularBuffer) { + self.map = emptyMap(); + self.length = 0; + self.start = 0; +} + +// Global static function for creating an empty CircularBuffer +fun emptyCircularBuffer(): CircularBuffer { + return CircularBuffer{m: emptyMap(), length: 0, start: 0}; // length and start default to 0 +} + +// This contract records the last 5 timestamps of when "timer" message was received +contract MapAsCircularBuffer with Deployable { + // Persistent state variables + cBuf: CircularBuffer; // our circular buffer, which uses a map + + // Constructor (initialization) function of the contract + init() { + self.cBuf = emptyCircularBuffer(); + } + + // Internal message receiver, which responds to a String message "timer" + // and records the timestamp when it receives such message + receive("timer") { + let timestamp: Int = now(); + self.cBuf.put(timestamp); + } + + // Internal message receiver, which responds to a String message "get_first" + // and replies with the first item of the circular buffer + receive("get_first") { + self.reply(self.cBuf.getIdx(0).toCoinsString().asComment()); + } + + // Internal message receiver, which responds to a String message "print_all" + receive("print_all") { + self.cBuf.printAll(); + } + + // Internal message receiver, which responds to a String message "delete_all" + receive("delete_all") { + self.cBuf.deleteAll(); + } +} +``` + +:::note + + This example is adapted from [Arrays page in Tact-By-Example](https://tact-by-example.org/04-arrays). + +::: + +:::tip[Hey there!] + + Didn't find your favorite example of working with data structures? Have cool implementations in mind? [Contributions are welcome!](https://github.com/tact-lang/tact/issues) + +::: + +[map]: /book/maps diff --git a/docs/src/content/docs/cookbook/dexes/dedust.mdx b/docs/src/content/docs/cookbook/dexes/dedust.mdx new file mode 100644 index 000000000..534c4af95 --- /dev/null +++ b/docs/src/content/docs/cookbook/dexes/dedust.mdx @@ -0,0 +1,13 @@ +--- +title: DeDust.io +sidebar: + order: 1 +--- + +[DeDust](https://dedust.io) is a decentralized exchange (DEX) and automated market maker (AMM) built natively on [TON Blockchain](https://ton.org) and [DeDust Protocol 2.0](https://docs.dedust.io/reference/tlb-schemes). DeDust is designed with a meticulous attention to user experience (UX), gas efficiency, and extensibility. + +:::danger[Not implemented] + + This page is a stub until it gets new content in [#146](https://github.com/tact-lang/tact-docs/issues/146). + +::: diff --git a/docs/src/content/docs/cookbook/dexes/stonfi.mdx b/docs/src/content/docs/cookbook/dexes/stonfi.mdx new file mode 100644 index 000000000..3663c582a --- /dev/null +++ b/docs/src/content/docs/cookbook/dexes/stonfi.mdx @@ -0,0 +1,13 @@ +--- +title: STON.fi +sidebar: + order: 2 +--- + +[STON.fi](https://ston.fi) is a decentralized automated market maker (AMM) built on [TON blockchain](https://ton.org) providing virtually zero fees, low slippage, an extremely easy interface, and direct integration with TON wallets. + +:::danger[Not implemented] + + This page is a stub until it gets new content in [#149](https://github.com/tact-lang/tact-docs/issues/149). + +::: diff --git a/docs/src/content/docs/cookbook/index.mdx b/docs/src/content/docs/cookbook/index.mdx new file mode 100644 index 000000000..d81e0c52e --- /dev/null +++ b/docs/src/content/docs/cookbook/index.mdx @@ -0,0 +1,84 @@ +--- +title: Cookbook overview +--- + +import { LinkCard, Card, CardGrid, Steps } from '@astrojs/starlight/components'; + +The main reason for making the Tact Cookbook is to gather all the experiences of Tact developers in one place so that future developers can use it. This section of the documentation is more focused on everyday tasks that every Tact developer resolves during the development of smart contracts. + +Use it as a recipe book for cooking up delightful smart contracts on TON Blockchain without re-inventing the wheel in the process. + + + +1. #### Single contract {#single-contract} + + Following pages focus on single-contract examples and cover a wide range of topics: + + + + + + + + + + + + +2. #### Multiple contracts {#multiple-contracts} + + Following pages focus on multi-contract examples, exploring the scalable nature of TON Blockchain: + + + + + + + + Additionally, there are examples of working with popular TON DEXes (Decentralized EXchanges), which often require many contracts and complex logic: + + + + + + + diff --git a/docs/src/content/docs/cookbook/jettons.mdx b/docs/src/content/docs/cookbook/jettons.mdx new file mode 100644 index 000000000..9863c1a61 --- /dev/null +++ b/docs/src/content/docs/cookbook/jettons.mdx @@ -0,0 +1,160 @@ +--- +title: Fungible Tokens (Jettons) +--- + +This page lists common examples of working with [jettons](https://docs.ton.org/develop/dapps/asset-processing/jettons). + +## Accepting jetton transfer + +Transfer notification message have the following structure. + +```tact +message(0x7362d09c) JettonTransferNotification { + queryId: Int as uint64; + amount: Int as coins; + sender: Address; + forwardPayload: Slice as remaining; +} +``` + +Use [receiver](/book/receive) function to accept token notification message. + +:::caution + + Sender of transfer notification must be validated! + +::: + +Validation can be done using jetton wallet state init and calculating jetton address. +Note, that notifications are coming from YOUR contract's jetton wallet, so [`myAddress()`](/ref/core-common#myaddress) should be used in owner address field. +Wallet initial data layout is shown below, but sometimes it can differ. +Note that `myJettonWalletAddress` may also be stored in contract storage to use less gas in every transaction. + +```tact +struct JettonWalletData { + balance: Int as coins; + ownerAddress: Address; + jettonMasterAddress: Address; + jettonWalletCode: Cell; +} + +fun calculateJettonWalletAddress(ownerAddress: Address, jettonMasterAddress: Address, jettonWalletCode: Cell): Address { + let initData = JettonWalletData{ + balance: 0, + ownerAddress, + jettonMasterAddress, + jettonWalletCode, + }; + + return contractAddress(StateInit{code: jettonWalletCode, data: initData.toCell()}); +} + +contract Sample { + jettonWalletCode: Cell; + jettonMasterAddress: Address; + + init(jettonWalletCode: Cell, jettonMasterAddress: Address) { + self.jettonWalletCode = jettonWalletCode; + self.jettonMasterAddress = jettonMasterAddress; + } + + receive(msg: JettonTransferNotification) { + let myJettonWalletAddress = calculateJettonWalletAddress(myAddress(), self.jettonMasterAddress, self.jettonWalletCode); + require(sender() == myJettonWalletAddress, "Notification not from your jetton wallet!"); + + // your logic of processing token notification + } +} +``` + +## Sending jetton transfer + +To send jetton transfer use [`send(){:tact}`](/book/send) function. +Note that `myJettonWalletAddress` may also be stored in contract storage to use less gas in every transaction. + +```tact +message(0xf8a7ea5) JettonTransfer { + queryId: Int as uint64; + amount: Int as coins; + destination: Address; + responseDestination: Address?; + customPayload: Cell? = null; + forwardTonAmount: Int as coins; + forwardPayload: Slice as remaining; +} + +receive("send") { + let myJettonWalletAddress = calculateJettonWalletAddress(myAddress(), self.jettonMasterAddress, self.jettonWalletCode); + send(SendParameters{ + to: myJettonWalletAddress, + value: ton("0.05"), + body: JettonTransfer{ + queryId: 42, + amount: jettonAmount, // jetton amount you want to transfer + destination: msg.userAddress, // address you want to transfer jettons. Note that this is address of jetton wallet owner, not jetton wallet itself + responseDestination: msg.userAddress, // address where to send a response with confirmation of a successful transfer and the rest of the incoming message Toncoins + customPayload: null, // in most cases will be null and can be omitted. Needed for custom logic on Jetton Wallets itself + forwardTonAmount: 1, // amount that will be transferred with JettonTransferNotification. Needed for custom logic execution like in example below. If the amount is 0 notification won't be sent + forwardPayload: rawSlice("F") // precomputed beginCell().storeUint(0xF, 4).endCell().beginParse(). This works for simple transfer, if needed any struct can be used as `forwardPayload` + }.toCell(), + }); +} +``` + +## Burning jetton + +```tact +message(0x595f07bc) JettonBurn { + queryId: Int as uint64; + amount: Int as coins; + responseDestination: Address?; + customPayload: Cell? = null; +} + +receive("burn") { + let myJettonWalletAddress = calculateJettonWalletAddress(myAddress(), self.jettonMasterAddress, self.jettonWalletCode); + send(SendParameters{ + to: myJettonWalletAddress, + body: JettonBurn{ + queryId: 42, + amount: jettonAmount, // jetton amount you want to burn + responseDestination: someAddress, // address where to send a response with confirmation of a successful burn and the rest of the incoming message coins + customPayload: null, // in most cases will be null and can be omitted. Needed for custom logic on jettons itself + }.toCell(), + }); +} +``` + +## USDT jetton operations + +Operations with USDT (on TON) remain the same, except that the `JettonWalletData` will have the following structure: + +```tact +struct JettonWalletData { + status: Ins as uint4; + balance: Int as coins; + ownerAddress: Address; + jettonMasterAddress: Address; +} +``` + +Function to calculate wallet address will look like this: + +```tact +fun calculateJettonWalletAddress(ownerAddress: Address, jettonMasterAddress: Address, jettonWalletCode: Cell): Address { + let initData = JettonWalletData{ + status: 0, + balance: 0, + ownerAddress, + jettonMasterAddress, + }; + + return contractAddress(StateInit{code: jettonWalletCode, data: initData.toCell()}); +} +``` + +:::tip[Hey there!] + + Didn't find your favorite example of jetton usage? Have cool implementations in mind? [Contributions are welcome!](https://github.com/tact-lang/tact/issues) + +::: diff --git a/docs/src/content/docs/cookbook/misc.mdx b/docs/src/content/docs/cookbook/misc.mdx new file mode 100644 index 000000000..05a4c9c44 --- /dev/null +++ b/docs/src/content/docs/cookbook/misc.mdx @@ -0,0 +1,37 @@ +--- +title: Miscellaneous +--- + +Various niche examples which don't yet have a dedicated page, but are useful and interesting nonetheless. + +## How to throw errors + +The `throw(){:tact}` function in a contract is useful when we don't know how often to perform a specific action. + +It allows intentional exception or error handling, which leads to the termination of the current transaction and reverts any state changes made during that transaction. + +```tact +let number: Int = 198; + +// the error will be triggered anyway +throw(36); + +// the error will be triggered only if the number is greater than 50 +nativeThrowIf(35, number > 50); + +// the error will be triggered only if the number is NOT EQUAL to 198 +nativeThrowUnless(39, number == 198); +``` + +:::note[Useful links:] + + [`throw(){:tact}` in Core library](/ref/core-debug#throw)\ + [Errors in Tact-By-Example](https://tact-by-example.org/03-errors) + +::: + +:::tip[Hey there!] + + Didn't find your favorite example of working with something niche? Have cool implementations in mind? [Contributions are welcome!](https://github.com/tact-lang/tact/issues) + +::: diff --git a/docs/src/content/docs/cookbook/multi-communication.mdx b/docs/src/content/docs/cookbook/multi-communication.mdx new file mode 100644 index 000000000..6c0504074 --- /dev/null +++ b/docs/src/content/docs/cookbook/multi-communication.mdx @@ -0,0 +1,9 @@ +--- +title: Multi-contract communication +--- + +:::danger[Not implemented] + + This page is a stub. [Contributions are welcome!](https://github.com/tact-lang/tact/issues) + +::: diff --git a/docs/src/content/docs/cookbook/nfts.mdx b/docs/src/content/docs/cookbook/nfts.mdx new file mode 100644 index 000000000..69c4626bc --- /dev/null +++ b/docs/src/content/docs/cookbook/nfts.mdx @@ -0,0 +1,9 @@ +--- +title: Non-Fungible Tokens (NFTs) +--- + +:::danger[Not implemented] + + This page is a stub. [Contributions are welcome!](https://github.com/tact-lang/tact/issues) + +::: diff --git a/docs/src/content/docs/cookbook/random.mdx b/docs/src/content/docs/cookbook/random.mdx new file mode 100644 index 000000000..14e578802 --- /dev/null +++ b/docs/src/content/docs/cookbook/random.mdx @@ -0,0 +1,31 @@ +--- +title: Randomness +--- + +This page lists examples of working with random numbers, uncertainty and randomness in general. + +## How to generate a random number + +```tact +// Declare a variable to store the random number +let number: Int; + +// Generate a new random number, which is an unsigned 256-bit integer +number = randomInt(); + +// Generate a random number between 1 and 12 +number = random(1, 12); +``` + +:::note[Useful links:] + + [`randomInt(){:tact}` in Core library](/ref/core-random#randomint)\ + [`random(){:tact}` in Core library](/ref/core-random#random) + +::: + +:::tip[Hey there!] + + Didn't find your favorite example of working with randomness? Have cool implementations in mind? [Contributions are welcome!](https://github.com/tact-lang/tact/issues) + +::: diff --git a/docs/src/content/docs/cookbook/single-communication.mdx b/docs/src/content/docs/cookbook/single-communication.mdx new file mode 100644 index 000000000..b1d7f4568 --- /dev/null +++ b/docs/src/content/docs/cookbook/single-communication.mdx @@ -0,0 +1,101 @@ +--- +title: Single-contract Communication +--- + +This page lists examples of communication of a single deployed contract with other contracts on blockchain. + +For examples of communication between multiple deployed contracts see: [Multi-contract communication](/cookbook/multi-communication). + +## How to make a basic reply + +```tact +receive() { + self.reply("Hello, World!".asComment()); // asComment converts a String to a Cell with a comment +} +``` + +## How to send a simple message + +```tact +send(SendParameters{ + bounce: true, // default + to: destinationAddress, + value: ton("0.01"), // attached amount of Tons to send + body: "Hello from Tact!".asComment(), // comment (optional) +}); +``` + +## How to send a message with the entire balance + +If we need to send the whole balance of the smart contract, then we should use the `SendRemainingBalance{:tact}` send mode. Alternatively, we can use `mode: 128{:tact}`, which has the same meaning. + +```tact +send(SendParameters{ + // bounce = true by default + to: sender(), // send the message back to the original sender + value: 0, + mode: SendRemainingBalance, // or mode: 128 + body: "Hello from Tact!".asComment(), // comment (optional) +}); +``` + +## How to send a message with the remaining value + +If we want to make a reply to the same sender, we can use the mode `SendRemainingValue{:tact}` (i.e. `mode: 64{:tact}`), which carries all the remaining value of the inbound message in addition to the value initially indicated in the new message. + +```tact +send(SendParameters{ + // bounce = true by default + to: sender(), // send the message back to the original sender + value: 0, + mode: SendRemainingValue, + body: "Hello from Tact!".asComment(), // comment (optional) +}); +``` + +It's often useful to add the `SendIgnoreErrors{:tact}` flag too, in order to ignore any errors arising while processing this message during the action phaseL + +```tact +send(SendParameters{ + // bounce = true by default + to: sender(), // send the message back to the original sender + value: 0, + mode: SendRemainingValue | SendIgnoreErrors, // prefer using | over + for the mode + body: "Hello from Tact!".asComment(), // comment (optional) +}); +``` + +The latter example is identical to using a [`.reply(){:tact}` function](#how-to-make-a-basic-reply). + +## How to send a message with a long text comment + +If we need to send a message with a lengthy text comment, we should create a [`String{:tact}`](/book/types#primitive-types) that consists of more than $127$ characters. To do this, we can utilize the [`StringBuilder{:tact}`](/book/types#primitive-types) primitive type and its methods called `beginComment(){:tact}` and `append(){:tact}`. Prior to sending, we should convert this string into a cell using the `toCell(){:tact}` method. + +```tact +let comment: StringBuilder = beginComment(); +let longString = "..."; // Some string with more than 127 characters. +comment.append(longString); + +send(SendParameters{ + // bounce = true by default + to: sender(), + value: 0, + mode: SendIgnoreErrors, + body: comment.toCell(), +}); +``` + +:::note[Useful links:] + + ["Sending messages" in the Book](/book/send#send-message)\ + ["Message `mode`" in the Book](/book/message-mode)\ + [`StringBuilder{:tact}` in the Book](/book/types#primitive-types)\ + [`Cell{:tact}` in Core library](/ref/core-cells) + +::: + +:::tip[Hey there!] + + Didn't find your favorite example of a single-contract communication? Have cool implementations in mind? [Contributions are welcome!](https://github.com/tact-lang/tact/issues) + +::: diff --git a/docs/src/content/docs/cookbook/time.mdx b/docs/src/content/docs/cookbook/time.mdx new file mode 100644 index 000000000..c8ac9b946 --- /dev/null +++ b/docs/src/content/docs/cookbook/time.mdx @@ -0,0 +1,30 @@ +--- +title: Time and date +--- + +## How to get the current time + +Use the `now(){:tact}` method to obtain the current standard [Unix time](https://en.wikipedia.org/wiki/Unix_time). + +If you need to store the time in state or encode it in a message, use the following [serialization](/book/integers#serialization): `Int as uint32{:tact}`. + +```tact +let currentTime: Int = now(); + +if (currentTime > 1672080143) { + // do something +} +``` + +:::note[Useful links:] + + [`now(){:tact}` in Core library](/ref/core-common#now)\ + ["Current Time" in Tact-By-Example](https://tact-by-example.org/04-current-time) + +::: + +:::tip[Hey there!] + + Didn't find your favorite example of working with time and date? Have cool implementations in mind? [Contributions are welcome!](https://github.com/tact-lang/tact/issues) + +::: diff --git a/docs/src/content/docs/cookbook/type-conversion.mdx b/docs/src/content/docs/cookbook/type-conversion.mdx new file mode 100644 index 000000000..345917e5f --- /dev/null +++ b/docs/src/content/docs/cookbook/type-conversion.mdx @@ -0,0 +1,150 @@ +--- +title: Type conversion +--- + +This page shows examples of converting between [primitive types][p] and obtaining them from [composite types](/book/types#composite-types). + +## `Int` ↔ `String` {#int-string} + +### How to convert a `String` to an `Int` + +```tact +// Defining a new extension function for type String that returns value of type Int +// Caution: produces unexpected results when String contains non-numeric characters! +extends fun toInt(self: String): Int { + // Cast the String as a Slice for parsing + let string: Slice = self.asSlice(); + + // A variable to store the accumulated number + let acc: Int = 0; + + // Loop until the String is empty + while (!string.empty()) { + let char: Int = string.loadUint(8); // load 8 bits (1 byte) from the Slice + acc = (acc * 10) + (char - 48); // using ASCII table to get numeric value + // Note, that this approach would produce unexpected results + // when the starting String contains non-numeric characters! + } + + // Produce the resulting number + return acc; +} + +fun runMe() { + let string: String = "26052021"; + dump(string.toInt()); +} +``` + +### How to convert an `Int` to a `String` + +```tact +let number: Int = 261119911; + +// Converting the [number] to a String +let numberString: String = number.toString(); + +// Converting the [number] to a float String, +// where passed argument 3 is the exponent of 10^(-3) of resulting float String, +// and it can be any integer between 0 and 76 including both ends +let floatString: String = number.toFloatString(3); + +// Converting the [number] as coins to a human-readable String +let coinsString: String = number.toCoinsString(); + +dump(numberString); // "261119911" +dump(floatString); // "261119.911" +dump(coinsString); // "0.261119911" +``` + +:::note[Useful links:] + + [`Int.toString(){:tact}` in Core library](/ref/core-strings#inttostring)\ + [`Int.toFloatString(){:tact}` in Core library](/ref/core-strings#inttofloatstring)\ + [`Int.toCoinsString(){:tact}` in Core library](/ref/core-strings#inttocoinsstring) + +::: + +## `Struct` or `Message` ↔ `Cell` or `Slice` {#structmessage-cellslice} + +### How to convert an arbitrary `Struct` or `Message` to a `Cell` or a `Slice` + +```tact {19-20, 22-23} +struct Profit { + big: String?; + dict: map; + energy: Int; +} + +message(0x45) Nice { + maybeStr: String?; +} + +fun convert() { + let st = Profit{ + big: null, + dict: null, + energy: 42, + }; + let msg = Nice{ maybeStr: "Message of the day!" }; + + st.toCell(); + msg.toCell(); + + st.toCell().asSlice(); + msg.toCell().asSlice(); +} +``` + +:::note[Useful links:] + + [`Struct.toCell(){:tact}` in Core library](/ref/core-cells#structtocell)\ + [`Message.toCell(){:tact}` in Core library](/ref/core-cells#messagetocell) + +::: + +### How to convert a `Cell` or a `Slice` to an arbitrary `Struct` or `Message` + +```tact {19-20, 22-23} +struct Profit { + big: String?; + dict: map; + energy: Int; +} + +message(0x45) Nice { + maybeStr: String?; +} + +fun convert() { + let stCell = Profit{ + big: null, + dict: null, + energy: 42, + }.toCell(); + let msgCell = Nice{ maybeStr: "Message of the day!" }.toCell(); + + Profit.fromCell(stCell); + Nice.fromCell(msgCell); + + Profit.fromSlice(stCell.asSlice()); + Nice.fromSlice(msgCell.asSlice()); +} +``` + +:::note[Useful links:] + + [`Struct.fromCell(){:tact}` in Core library](/ref/core-cells#structfromcell)\ + [`Struct.fromSlice(){:tact}` in Core library](/ref/core-cells#structfromslice)\ + [`Message.fromCell(){:tact}` in Core library](/ref/core-cells#messagefromcell)\ + [`Message.fromSlice(){:tact}` in Core library](/ref/core-cells#messagefromslice) + +::: + +:::tip[Hey there!] + + Didn't find your favorite example of type conversion? Have cool implementations in mind? [Contributions are welcome!](https://github.com/tact-lang/tact/issues) + +::: + +[p]: /book/types#primitive-types diff --git a/docs/src/content/docs/ecosystem/index.mdx b/docs/src/content/docs/ecosystem/index.mdx new file mode 100644 index 000000000..923326a81 --- /dev/null +++ b/docs/src/content/docs/ecosystem/index.mdx @@ -0,0 +1,36 @@ +--- +title: Ecosystem overview +--- + +import { CardGrid, LinkCard, Steps } from '@astrojs/starlight/components'; + +Welcome to the **Ecosystem** section — a bird-eye overview of Tact ecosystem, tools and ways you can start contributing to those! + +Here are its main contents: + + + +1. #### Tools + + Tools is a list of official and community-made tools made specifically for Tact, or whose that play along with the language and other tools. Each tool has a brief usage details and additional information, which sometimes is missing from the respective docs or is a convenient summary available only in the Tact documentation. + + + + + + + + + diff --git a/docs/src/content/docs/ecosystem/jetbrains.mdx b/docs/src/content/docs/ecosystem/jetbrains.mdx new file mode 100644 index 000000000..a135f1dc6 --- /dev/null +++ b/docs/src/content/docs/ecosystem/jetbrains.mdx @@ -0,0 +1,25 @@ +--- +title: TON development plugin for JetBrains IDEs +--- + +Supports highlighting Tact's syntax in JetBrains IDEs versioned **2023.** and later. Note, that besides support for Tact, it also includes a rich support of FunC and Fift languages of TON Blockchain, as well as TL-B schemas. + +Plugin on the JetBrains Marketplace: [TON Development Plugin](https://plugins.jetbrains.com/plugin/23382-ton) + +## Installation manual + +1. Open your JetBrains IDE (IntelliJ IDEA, PyCharm, WebStorm, etc.) +2. Navigate to the **Plugin Marketplace** by selecting `File > Settings/Preferences > Plugins` +3. In the Plugin Marketplace's search bar, type "TON Development". You will see a dropdown with the extension provided by `TON Foundation`. +4. Click the **Install** button next to the plugin name. Wait for the installation to complete. +5. Once the plugin is installed, you will be prompted to restart your JetBrains IDE. Click the **Restart** button to apply changes. +6. After restarting, the TON Development plugin should now be successfully installed in your JetBrains IDE. + +## Troubleshooting + +If you encounter issues during the installation process, please consult the [plugin's GitHub repository](https://github.com/ton-blockchain/intellij-ton) for solutions and further information. + +## References and Resources + +- [Plugin on GitHub](https://github.com/ton-blockchain/intellij-ton) +- [Plugin on the JetBrains Marketplace](https://plugins.jetbrains.com/plugin/23382-ton) diff --git a/docs/src/content/docs/ecosystem/misti.mdx b/docs/src/content/docs/ecosystem/misti.mdx new file mode 100644 index 000000000..eec7b6718 --- /dev/null +++ b/docs/src/content/docs/ecosystem/misti.mdx @@ -0,0 +1,20 @@ +--- +title: Misti static analyzer +--- + +[Misti](https://nowarp.github.io/tools/misti/) is a static program analysis tool that supports Tact. + +## What is Misti? + +* **Static Program Analysis**: Misti analyzes code without executing it, scanning for [bugs and security flaws](https://nowarp.github.io/tools/misti/docs/detectors) by examining the structure and syntax. This approach catches issues early, preventing them from reaching production. + +* **Custom Detectors**: Customize Misti to your specific needs by creating [custom detectors](https://nowarp.github.io/tools/misti/docs/hacking/custom-detector). This helps identify vulnerabilities that generic tools might miss, ensuring a thorough review of your code. + +* **CI/CD Integration**: [Integrate](https://nowarp.github.io/tools/misti/docs/tutorial/ci-cd) Misti into your CI/CD pipeline to ensure continuous code quality checks, catching issues before they make it to production. + +## Resources + +* [Github](https://github.com/nowarp/misti) +* [Telegram Community](https://t.me/misti_dev) +* [Misti Documentation](https://nowarp.github.io/docs/misti/) +* [Misti API Reference](https://nowarp.github.io/docs/misti/api) diff --git a/docs/src/content/docs/ecosystem/typescript.mdx b/docs/src/content/docs/ecosystem/typescript.mdx new file mode 100644 index 000000000..5b7f9c7b0 --- /dev/null +++ b/docs/src/content/docs/ecosystem/typescript.mdx @@ -0,0 +1,9 @@ +--- +title: TypeScript libraries +--- + +The Tact language has built-in support for the [@ton/ton](https://github.com/ton-org/ton) and [@ton/core](https://github.com/ton-org/ton-core) TypeScript libraries. The compiler automatically generates code for these libraries, so you can use [@tact-lang/emulator](https://github.com/tact-lang/tact-emulator) or [@ton/sandbox](https://github.com/ton-org/sandbox), that work on top of them. + +## Tact contract in TypeScript + +The compiler generates files named `{project}_{contract}.ts` for each contract in your [project](/book/config#projects), which contain ready-to-use strongly typed wrappers for working with it in any TypeScript-powered environment: for [testing](/book/debug), [deployments](/book/deploy), etc. diff --git a/docs/src/content/docs/ecosystem/vscode.mdx b/docs/src/content/docs/ecosystem/vscode.mdx new file mode 100644 index 000000000..646980530 --- /dev/null +++ b/docs/src/content/docs/ecosystem/vscode.mdx @@ -0,0 +1,62 @@ +--- +title: VS Code extension +--- + +Provides extensive support for Tact language in the Visual Studio Code: + +* Syntax highlighting +* Error highlighting +* Snippets +* Information on hover +* Code completion for all variables, functions, global parameters and unique types of Tact +* Code completion for all contracts / libraries in the current file and all referenced imports +* Formatting + +Extension on the VS Code Marketplace: [Tact Language Support for TON blockchain](https://marketplace.visualstudio.com/items?itemName=KonVik.tact-lang-vscode) + +## Installation manual + +1. Open Visual Studio Code (shortly referred to as VS Code). + +2. Navigate to the Extensions view by clicking on the Extensions icon in the Activity Bar on the side of the window. It looks like a square within a square. + +3. In the Extensions view input box, type "Tact Language". You should see a dropdown with the extension "Tact Language" provided by KonVik. Probably, you would see the similar extension provided by TON Community, but that one is deprecated and **we should use KonVik's one instead**. + +4. Click on the install button next to the extension name. Wait until the installation is complete. + +5. Once the extension is installed, you might need to reload VS Code. If necessary, there will be a Reload button next to the extension. Click on this button if it appears. + +6. The Tact Language extension should now be installed on your VS Code. + +## Enabling `Format on Save` {#format-on-save} + +This guide will provide instructions on how to enable the Format on Save feature for the Tact Language extension in VS Code using the Command Palette and editing the JSON settings file. + +1. Type `Preferences: Open Settings (JSON)` in the command palette. This will open your `settings.json` file. + +2. Editing JSON Settings + + - You'll see a JSON object. We're going to add some properties to this object to enable format on save for the Tact Language extension. + - Add the following lines inside the JSON object: + + ```json + { + "[tact]": { + "editor.formatOnSave": true, + "editor.defaultFormatter": "KonVik.tact-lang-vscode" + } + } + ``` + + - This will enable format on save (`"editor.formatOnSave": true`) and set the default formatter for Tact files (`"[tact]": {"editor.defaultFormatter": "KonVik.tact-lang-vscode"}`) to the Tact Language extension. + +3. Saving and Closing Settings + - Save your `settings.json` file after adding these lines (You can press `Ctrl+S` to save). + - Close the `settings.json` tab or press `Ctrl+W`. + +Your Tact Language VS Code extension should now automatically format your files when you save them. If you don't see these changes take effect immediately, you might need to reload VS Code. + +## References and Resources + +- [Extension on GitHub](https://github.com/tact-lang/tact-vscode) +- [Extension on the VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=KonVik.tact-lang-vscode) diff --git a/docs/src/content/docs/index.mdx b/docs/src/content/docs/index.mdx new file mode 100644 index 000000000..5faa5c8d3 --- /dev/null +++ b/docs/src/content/docs/index.mdx @@ -0,0 +1,196 @@ +--- +title: Learn all about programming in ⚡ Tact +description: Tact is a new programming language for TON Blockchain that is focused on efficiency and simplicity. It is designed to be easy to learn and use, and to be a good fit for smart contracts. +template: splash +hero: + tagline: Tact is a new programming language for TON Blockchain that is focused on efficiency and simplicity. It is designed to be easy to learn and use, and to be a good fit for smart contracts. Tact is a statically typed language with a simple syntax and a powerful type system. + image: + dark: ../../../public/logomark-dark.svg + light: ../../../public/logomark-light.svg + alt: Tact logo + actions: + - text: 📚 Book + link: /book + variant: minimal + icon: right-arrow + + - text: 🍲 Cookbook + link: /cookbook + variant: minimal + icon: right-arrow + + - text: 🔬 Reference + link: /ref + variant: minimal + icon: right-arrow + + - text: 🗺️ Ecosystem + link: /ecosystem + variant: minimal + icon: right-arrow +--- + +import { LinkCard, CardGrid, Tabs, TabItem, Steps } from '@astrojs/starlight/components'; + + {/* icon: right-arrow */} + +## 🚀 Let's start! {#start} + +

ㅤ

+ + + +1. #### Ensure that the supported version of Node.js is installed and available {#start-1} + + To check it, run `node --version{:shell}` — it should show you the version 22.0.0 or later. + +2. #### Run the following command {#start-2} + + It will create a new project with the simple counter contract: + + + + ```shell + # recommended + yarn create ton simple-counter --type tact-counter --contractName SimpleCounter + ``` + + + ```shell + npm create ton@latest -- simple-counter --type tact-counter --contractName SimpleCounter + ``` + + + ```shell + pnpm create ton@latest simple-counter --type tact-counter --contractName SimpleCounter + ``` + + + ```shell + bun create ton@latest simple-counter --type tact-counter --contractName SimpleCounter + ``` + + + +3. #### That's it! {#start-3} + + Your first contract project is written and compiled already! + + Go check it out by moving into the relevant directory — `cd simple-counter/contracts{:shell}`. Here's how it would look like: + + ```tact + import "@stdlib/deploy"; + + message Add { + queryId: Int as uint64; + amount: Int as uint32; + } + + contract SimpleCounter with Deployable { + id: Int as uint32; + counter: Int as uint32; + + init(id: Int) { + self.id = id; + self.counter = 0; + } + + receive(msg: Add) { + self.counter += msg.amount; + + // Notify the caller that the receiver was executed and forward remaining value back + self.notify("Cashback".asComment()); + } + + get fun counter(): Int { + return self.counter; + } + + get fun id(): Int { + return self.id; + } + } + ``` + + To re-compile or deploy, refer to the commands in the scripts section of `package.json` in the root of this newly created project and to the documentation of [Blueprint](https://github.com/ton-org/blueprint) — this is the tool we've used to create and compile your first simple counter contract in Tact. In fact, Blueprint can do much more than that: including tests, customizations and more. + + + +## 🤔 Where to go next? {#next} + +

ㅤ

+ + + +1. #### Have some blockchain knowledge already? {#next-1} + + See the [Tact Cookbook](/cookbook), which is a handy collection of everyday tasks (and solutions) every Tact developer faces during smart contract development. Use it to avoid re-inventing the wheel. + + Alternatively, check the following cheat sheets to quickly get started: + + + + + + +2. #### Want to know more? {#next-2} + + For further guidance on compilation, testing and deployment see the respective pages: + + * [Testing and debugging](/book/debug) page tells you everything about debugging Tact contracts + * [Deployment](/book/deploy) page shows what deployment looks like and helps you harness the powers of [Blueprint](https://github.com/ton-org/blueprint) for it. + + For custom plugins for your favorite editor and other tooling see the [Ecosystem](/ecosystem) section. + + Alternatively, take a look at the following broader sections: + + * [Book](/book) helps you learn the language step-by-step + * [Cookbook](/cookbook) gives you ready-made recipes of Tact code + * [Reference](/ref) provides a complete glossary of the standard library, grammar and evolution process + * Finally, [Ecosystem](/ecosystem) describes "what's out there" in the Tact's and TON's ecosystems + + + + + + + + +3. #### Feeling a bit uncomfortable? {#next-3} + + If you ever get stuck, try searching — the search box is right at the top of the documentation. There is also a handy Ctrl + K shortcut to quickly focus and start the search as you type. + + If you can't find the answer in the docs, or you've tried to do some local testing and it still didn't help — don't hesitate to reach out to Tact's flourishing community: + + + + + + + Good luck on your coding adventure with ⚡ Tact! + + diff --git a/docs/src/content/docs/ref/core-advanced.mdx b/docs/src/content/docs/ref/core-advanced.mdx new file mode 100644 index 000000000..7462115bb --- /dev/null +++ b/docs/src/content/docs/ref/core-advanced.mdx @@ -0,0 +1,255 @@ +--- +title: Advanced +--- + +Various niche, dangerous or unstable features which can produce unexpected results and are meant to be used by the more experienced users. + +:::caution + + Proceed with caution. + +::: + +## Context.readForwardFee + +```tact +extends fun readForwardFee(self: Context): Int +``` + +Extension function for the [`Context{:tact}`](/ref/core-common#context). + +Reads [forward fee](https://docs.ton.org/develop/smart-contracts/guidelines/processing) and returns it as [`Int{:tact}`][int] amount of [nanoToncoins](/book/integers#nanotoncoin). + +Usage example: + +```tact +let fwdFee: Int = context().readForwardFee(); +``` + +## getConfigParam + +```tact +fun getConfigParam(id: Int): Cell?; +``` + +Loads a [configuration parameter](https://docs.ton.org/develop/howto/blockchain-configs) of TON Blockchain by its `id` number. + +Usage examples: + +```tact +// Parameter 0, address of a special smart contract that stores the blockchain's configuration +let configAddrAsCell: Cell = getConfigParam(0)!!; + +// Parameter 18, configuration for determining the prices for data storage +let dataStorageFeeConfig: Cell = getConfigParam(18)!!; +``` + +:::note + + Standard library [`@stdlib/config`](/ref/stdlib-config) provides two related helper functions:\ + [`getConfigAddress(){:tact}`](/ref/stdlib-config#getconfigaddress) for retrieving config [`Address{:tact}`][p]\ + [`getElectorAddress(){:tact}`](/ref/stdlib-config#getconfigaddress) for retrieving elector [`Address{:tact}`][p] + + Read more about other parameters: [Config Parameters in TON Docs](https://docs.ton.org/develop/howto/blockchain-configs). + +::: + +## acceptMessage + +```tact +fun acceptMessage(); +``` + +Agrees to buy some gas to finish the current transaction. This action is required to process external messages, which bring no value (hence no gas) with themselves. + +Usage example: + +```tact {10} +contract Timeout { + timeout: Int; + + init() { + self.timeout = now() + 5 * 60; // 5 minutes from now + } + + external("timeout") { + if (now() > self.timeout) { + acceptMessage(); // start accepting external messages once timeout went out + } + } +} +``` + +:::note + + For more details, see: [Accept Message Effects in TON Docs](https://docs.ton.org/develop/smart-contracts/guidelines/accept). + +::: + +## commit + +```tact +fun commit(); +``` + +Commits the current state of [registers](https://docs.ton.org/learn/tvm-instructions/tvm-overview#control-registers) `c4` ("persistent data") and `c5` ("actions"), so that the current execution is considered "successful" with the saved values even if an exception in compute phase is thrown later. + +Usage example: + +```tact {1} +commit(); // now, transaction is considered "successful" +throw(42); // and this won't fail it +``` + +## nativePrepareRandom + +```tact +fun nativePrepareRandom(); +``` + +Prepares a random number generator by using [`nativeRandomizeLt(){:tact}`](#nativerandomizelt). Automatically called by [`randomInt(){:tact}`](/ref/core-random#randomint) and [`random(){:tact}`](/ref/core-random#random) functions. + +Usage example: + +```tact +nativePrepareRandom(); // prepare the RNG +// ... do your random things ... +``` + +## nativeRandomize + +```tact +fun nativeRandomize(x: Int); +``` + +Randomizes the pseudo-random number generator with the specified seed `x`. + +Usage example: + +```tact +nativeRandomize(); // now, random numbers are less predictable +let idk: Int = randomInt(); // ???, it's random! +``` + +## nativeRandomizeLt + +```tact +fun nativeRandomizeLt(); +``` + +Randomizes the random number generator with the current [logical time](https://docs.ton.org/develop/smart-contracts/guidelines/message-delivery-guarantees#what-is-a-logical-time). + +Usage example: + +```tact +nativeRandomizeLt(); // now, random numbers are unpredictable for users, + // but still may be affected by validators or collators + // as they determine the seed of the current block. +let idk: Int = randomInt(); // ???, it's random! +``` + +## nativeRandom + +```tact +fun nativeRandom(): Int; +``` + +Generates and returns an $256$-bit random number just like [`randomInt(){:tact}`](/ref/core-random#randomint), but doesn't initialize the random generator with [`nativePrepareRandom(){:tact}`](#nativepreparerandom) beforehand. + +:::note + + Don't use this function directly, and prefer using [`randomInt(){:tact}`](/ref/core-random#randomint) instead. + +::: + +## nativeRandomInterval + +```tact +fun nativeRandomInterval(max: Int): Int; +``` + +Generates and returns a $256$-bit random number in the range from $0$ to `max` similar to [`random(){:tact}`](/ref/core-random#random), but doesn't initialize the random generator with [`nativePrepareRandom(){:tact}`](#nativepreparerandom) beforehand. + +:::note + + Don't use this function directly, and prefer using [`random(){:tact}`](/ref/core-random#random) instead. + +::: + +## nativeSendMessage + +```tact +fun nativeSendMessage(cell: Cell, mode: Int); +``` + +[Queues the message](/book/send#outbound-message-processing) to be sent by specifying the complete `cell` and the [message `mode`](/book/message-mode). + +:::note + + Prefer using a much more common and user-friendly [`send(){:tact}`](/ref/core-common#send) function unless you have a complex logic that can't be expressed otherwise. + +::: + +## nativeReserve + +```tact +fun nativeReserve(amount: Int, mode: Int); +``` + +Calls native `raw_reserve` function with specified amount and mode. The `raw_reserve` is a function that creates an output action to reserve a specific amount of [nanoToncoins](/book/integers#nanotoncoin) from the remaining balance of the account. + +It has the following signature in FunC: + +```func +raw_reserve(int amount, int mode) impure asm "RAWRESERVE"; +``` + +The function takes two arguments: +* `amount`: The number of [nanoToncoins](/book/integers#nanotoncoin) to reserve. +* `mode`: Determines the reservation behavior. + +Function `raw_reserve` is roughly equivalent to creating an outbound message carrying the specified `amount` of [nanoToncoins](/book/integers#nanotoncoin) (or `b` $-$ `amount` [nanoToncoins](/book/integers#nanotoncoin), where `b` is the remaining balance) to oneself. This ensures that subsequent output actions cannot spend more money than the remainder. + +It's possible to use raw [`Int{:tact}`][int] values and manually provide them for the `mode`, but for your convenience there's a set of constants which you may use to construct the compound `mode` with ease. Take a look at the following tables for more information on base modes and optional flags. + +:::caution + + Currently, `amount` must be a non-negative integer, and `mode` must be in the range $0..31$, inclusive. + +::: + +### Base modes {#nativereserve-base-modes} + +The resulting `mode` value can have the following base modes: + +Mode value | Constant name | Description +---------: | :---------------------------- | ----------- +$0$ | `ReserveExact{:tact}` | Reserves exactly the specified `amount` of [nanoToncoins](/book/integers#nanotoncoin). +$1$ | `ReserveAllExcept{:tact}` | Reserves all, but the specified `amount` of [nanoToncoins](/book/integers#nanotoncoin). +$2$ | `ReserveAtMost{:tact}` | Reserves at most the specified `amount` of [nanoToncoins](/book/integers#nanotoncoin). + +### Optional flags {#nativereserve-optional-flags} + +Additionally, the resulting `mode` can have the following optional flags added: + +Flag value | Constant name | Description +---------: | :--------------------------------- | ----------- +$+4$ | `ReserveAddOriginalBalance{:tact}` | Increases the `amount` by the original balance of the current account (before the compute phase), including all extra currencies. +$+8$ | `ReserveInvertSign{:tact}` | Negates the `amount` value before performing the reservation. +$+16$ | `ReserveBounceIfActionFail{:tact}` | Bounces the transaction if reservation fails. + +### Combining modes with flags {#nativereserve-combining-modes-with-flags} + +To make the [`Int{:tact}`][int] value for `mode` parameter, you just have to combine base modes with optional flags by applying the [bitwise OR](/book/operators#binary-bitwise-or) operation: + +```tact +nativeReserve(ton("0.1"), ReserveExact | ReserveBounceIfActionFail); +// ---------- ---------------------------------------- +// ↑ ↑ +// | mode, which would bounce the transaction if exact reservation would fail +// amount of nanoToncoins to reserve +``` + +[p]: /book/types#primitive-types +[bool]: /book/types#booleans +[int]: /book/integers diff --git a/docs/src/content/docs/ref/core-base.mdx b/docs/src/content/docs/ref/core-base.mdx new file mode 100644 index 000000000..532040bc7 --- /dev/null +++ b/docs/src/content/docs/ref/core-base.mdx @@ -0,0 +1,127 @@ +--- +title: Base trait +--- + +Every [contract](/book/contracts) and [trait](/book/types#traits) in Tact implicitly [inherits](/book/contracts#traits) the `BaseTrait{:tact}` trait, which contains a number of the most useful [internal functions](/book/contracts#internal-functions) for any kind of contract, and a constant `self.storageReserve{:tact}` aimed at advanced users of Tact. + +## Constants + +### self.storageReserve {#self-storagereserve} + +```tact +virtual const storageReserve: Int = 0; +``` + +Usage example: + +```tact +contract AllYourStorageBelongsToUs { + // This would change the behavior of self.forward() function, + // causing it to try reserving this amount of nanoToncoins before + // forwarding a message with SendRemainingBalance mode + override const storageReserve: Int = ton("0.1"); +} +``` + +## Functions + +### self.reply {#self-reply} + +```tact +virtual fun reply(body: Cell?); +``` + +An alias to calling the [`self.forward(){:tact}`](#self-forward) function with the following arguments: + +```tact +self.forward(sender(), body, true, null); +// ↑ ↑ ↑ ↑ +// | | | init: StateInit? +// | | bounce: Bool +// | body: Cell? +// to: Address +``` + +Usage example: + +```tact +// This message can bounce back to us! +self.reply("Beware, this is my reply to you!".asComment()); +``` + +### self.notify {#self-notify} + +```tact +virtual fun notify(body: Cell?); +``` + +An alias to calling the [`self.forward(){:tact}`](#self-forward) function with the following arguments: + +```tact +self.forward(sender(), body, false, null); +// ↑ ↑ ↑ ↑ +// | | | init: StateInit? +// | | bounce: Bool +// | body: Cell? +// to: Address +``` + +Usage example: + +```tact +// This message won't bounce! +self.notify("Beware, this is my reply to you!".asComment()); +``` + +### self.forward {#self-forward} + +```tact +virtual fun forward(to: Address, body: Cell?, bounce: Bool, init: StateInit?); +``` + +[Queues the message](/book/send#outbound-message-processing) (bounceable or non-bounceable) to be sent to the specified address `to`. Optionally, you may provide a `body` of the message and the [`init` package](/book/expressions#initof). + +When [`self.storageReserve{:tact}`](#self-storagereserve) constant is overwritten to be $> 0$, before sending a message it also tries to reserve the `self.storageReserve{:tact}` amount of [nanoToncoins][nano] from the remaining balance before making the send in the [`SendRemainingBalance{:tact}`](https://docs.tact-lang.org/book/message-mode#base-modes) ($128$) mode. + +In case reservation attempt fails and in the default case without the attempt, the message is sent with the [`SendRemainingValue{:tact}`](https://docs.tact-lang.org/book/message-mode#base-modes) ($64$) mode instead. + +:::note + + Note, that `self.forward(){:tact}` never sends additional [nanoToncoins][nano] on top of what's available on the balance.\ + To be able to send more [nanoToncoins][nano] with a single message, use the the [`send(){:tact}`](/ref/core-common#send) function. + +::: + +Usage example: + +```tact +import "@stdlib/ownable"; + +message PayoutOk { + address: Address; + value: Int as coins; +} + +contract Payout with Ownable { + completed: Bool; + owner: Address; + + init(owner: Address) { + self.owner = owner; + self.completed = false; + } + + // ... some actions there ... + + // Bounced receiver function, which is called when the specified outgoing message bounces back + bounced(msg: bounced) { + // Reset completed flag if our message bounced + self.completed = false; + + // Send a notification that the payout failed using the remaining funds for processing this send + self.forward(self.owner, "Payout failed".asComment(), false, null); + } +} +``` + +[nano]: /book/integers#nanotoncoin diff --git a/docs/src/content/docs/ref/core-cells.mdx b/docs/src/content/docs/ref/core-cells.mdx new file mode 100644 index 000000000..06a1c1ba0 --- /dev/null +++ b/docs/src/content/docs/ref/core-cells.mdx @@ -0,0 +1,964 @@ +--- +title: Cells, Builders and Slices +--- + +[`Cell{:tact}`][cell] is a low-level [primitive][p] that represents data in TON Blockchain. Cells consist of $1023$ bits of data with up to $4$ references to another cells. They are read-only and immutable, and cannot have cyclic references. + +[`Builder{:tact}`][builder] is an immutable [primitive][p] to construct cells, and [`Slice{:tact}`][slice] is a mutable [primitive][p] to parse them. + +:::note + + Be very careful when constructing and parsing cells manually, and always make sure to document their desired layout: a strict order of values and types for serialization and deserialization. + + To do so, advanced users are recommended to use [Type Language - Binary (TL-B) schemas][tlb]. + + And every user is recommended to use [Structs][struct] and their [methods](/book/functions#extension-function) like [`Struct.toCell(){:tact}`](#structtocell) and [`Struct.fromCell(){:tact}`](#structfromcell) instead of manually constructing and parsing cells, because [Structs][struct] and [Messages][message] are closest to being the [living TL-B schemas of your contracts](/book/cells#cnp-structs). + +::: + +## beginCell + +```tact +fun beginCell(): Builder +``` + +Creates a new empty [`Builder{:tact}`][builder]. + +Usage example: + +```tact +let fizz: Builder = beginCell(); +``` + +## emptyCell + +```tact +fun emptyCell(): Cell; +``` + +Creates and returns an empty [`Cell{:tact}`][cell] (without data and references). Alias to `beginCell().endCell(){:tact}`. + +Usage example: + +```tact +let fizz: Cell = emptyCell(); +let buzz: Cell = beginCell().endCell(); + +fizz == buzz; // true +``` + +## emptySlice + +```tact +fun emptySlice(): Slice; +``` + +Creates and returns an empty [`Slice{:tact}`][slice] (without data and references). Alias to `emptyCell().asSlice(){:tact}`. + +Usage example: + +```tact +let fizz: Slice = emptySlice(); +let buzz: Slice = emptyCell().asSlice(); + +fizz == buzz; // true +``` + +## Cell.beginParse + +```tact +extends fun beginParse(self: Cell): Slice; +``` + +Extension function for the [`Cell{:tact}`][cell]. + +Opens the [`Cell{:tact}`][cell] for parsing and returns it as a [`Slice{:tact}`][slice]. + +Usage example: + +```tact +let c: Cell = emptyCell(); +let fizz: Slice = c.beginParse(); +``` + +## Cell.hash + +```tact +extends fun hash(self: Cell): Int; +``` + +Extension function for the [`Cell{:tact}`][cell]. + +Calculates and returns an [`Int{:tact}`][int] value of the [SHA-256][sha-2] hash of the [standard `Cell{:tact}` representation][std-repr] of the given [`Cell{:tact}`][cell]. + +Usage example: + +```tact +let c: Cell = emptyCell(); +let fizz: Int = c.hash(); +``` + +## Cell.asSlice + +```tact +extends fun asSlice(self: Cell): Slice; +``` + +Extension function for the [`Cell{:tact}`][cell]. + +Converts the Cell to a [`Slice{:tact}`][slice] and returns it. Alias to `self.beginParse(){:tact}`. + +Usage example: + +```tact +let c: Cell = emptyCell(); +let fizz: Slice = c.asSlice(); +``` + +## Builder.endCell + +```tact +extends fun endCell(self: Builder): Cell; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Converts a [`Builder{:tact}`][builder] into an ordinary [`Cell{:tact}`][cell]. + +Usage example: + +```tact +let b: Builder = beginCell(); +let fizz: Cell = b.endCell(); +``` + +## Builder.storeUint + +```tact +extends fun storeUint(self: Builder, value: Int, bits: Int): Builder; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Stores an unsigned `bits`-bit `value` into the copy of the [`Builder{:tact}`][builder] for $0 ≤$ `bits` $≤ 256$. Returns that copy. + +Attempts to store a negative `value` or provide an insufficient or out-of-bounds `bits` number throw an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Usage example: + +```tact +let b: Builder = beginCell(); +let fizz: Builder = b.storeUint(42, 6); +``` + +## Builder.storeInt + +```tact +extends fun storeInt(self: Builder, value: Int, bits: Int): Builder; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Stores a signed `bits`-bit `value` into the copy of the [`Builder{:tact}`][builder] for $0 ≤$ `bits` $≤ 257$. Returns that copy. + +Attempts to provide an insufficient or out-of-bounds `bits` number throw an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Usage example: + +```tact +let b: Builder = beginCell(); +let fizz: Builder = b.storeUint(42, 7); +``` + +## Builder.storeBool + +```tact +extends fun storeBool(self: Builder, value: Bool): Builder; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Stores a [`Bool{:tact}`][bool] `value` into the copy of the [`Builder{:tact}`][builder]. Writes $1$ as a single bit if `value` is `true{:tact}`, and writes $0$ otherwise. Returns that copy of the [`Builder{:tact}`][builder]. + +Usage example: + +```tact +let b: Builder = beginCell(); +let fizz: Builder = b.storeBool(true); // writes 1 +let buzz: Builder = b.storeBool(false); // writes 0 +``` + +## Builder.storeSlice + +```tact +extends fun storeSlice(self: Builder, cell: Slice): Builder; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Stores a [`Slice{:tact}`][slice] `cell` into the copy of the [`Builder{:tact}`][builder]. Returns that copy. + +Usage example: + +```tact +let b: Builder = beginCell(); +let s: Slice = emptyCell().asSlice(); +let fizz: Builder = b.storeSlice(s); +``` + +## Builder.storeCoins + +```tact +extends fun storeCoins(self: Builder, value: Int): Builder; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Stores (serializes) an unsigned [`Int{:tact}`][int] `value` in the range $0 .. 2^{120} − 1$ into the copy of the [`Builder{:tact}`][builder]. The serialization of `value` consists of a $4$-bit unsigned big-endian integer $l$, which is the smallest integer $l ≥ 0$, such that `value` $< 2^{8 * l}$, followed by an $8 * l$-bit unsigned big-endian representation of `value`. Returns that copy of the [`Builder{:tact}`][builder]. + +Attempts to store an out-of-bounds `value` throw an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +This is the most common way of storing [nanoToncoins](/book/integers#nanotoncoin). + +Usage example: + +```tact +let b: Builder = beginCell(); +let fizz: Builder = b.storeCoins(42); +``` + +:::note[Useful links:] + + [Special `coins` serialization type](/book/integers#serialization-coins) + +::: + +## Builder.storeAddress + +```tact +extends fun storeAddress(self: Builder, address: Address): Builder; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Stores the `address` in the copy of the [`Builder{:tact}`][builder]. Returns that copy. + +Usage example: + +```tact +let b: Builder = beginCell(); +let fizz: Builder = b.storeAddress(myAddress()); +``` + +## Builder.storeRef + +```tact +extends fun storeRef(self: Builder, cell: Cell): Builder; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Stores a reference `cell` into the copy of the [`Builder{:tact}`][builder]. Returns that copy. + +As a single [`Cell{:tact}`][cell] can store up to $4$ references, attempts to store more throw an exception with [exit code 8](/book/exit-codes#8): `Cell overflow`. + +Usage example: + +```tact +let b: Builder = beginCell(); +let fizz: Builder = b.storeRef(emptyCell()); +``` + +## Builder.refs + +```tact +extends fun refs(self: Builder): Int; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Returns the number of cell references already stored in the [`Builder{:tact}`][builder] as an [`Int{:tact}`][int]. + +Usage example: + +```tact +let b: Builder = beginCell(); +let fizz: Int = b.refs(); // 0 +``` + +## Builder.bits + +```tact +extends fun bits(self: Builder): Int; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Returns the number of data bits already stored in the [`Builder{:tact}`][builder] as an [`Int{:tact}`][int]. + +Usage example: + +```tact +let b: Builder = beginCell(); +let fizz: Int = b.bits(); // 0 +``` + +## Builder.asSlice + +```tact +extends fun asSlice(self: Builder): Slice; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Converts the [`Builder{:tact}`][builder] to a [`Slice{:tact}`][slice] and returns it. Alias to `self.endCell().beginParse(){:tact}`. + +Usage example: + +```tact +let b: Builder = beginCell(); +let fizz: Slice = b.asSlice(); +``` + +## Builder.asCell + +```tact +extends fun asCell(self: Builder): Cell; +``` + +Extension function for the [`Builder{:tact}`][builder]. + +Converts the [`Builder{:tact}`][builder] to a [`Cell{:tact}`][cell] and returns it. Alias to `self.endCell(){:tact}`. + +Usage example: + +```tact +let b: Builder = beginCell(); +let fizz: Cell = b.asCell(); +``` + +## Slice.loadUint + +```tact +extends mutates fun loadUint(self: Slice, l: Int): Int; +``` + +Extension mutation function for the [`Slice{:tact}`][slice]. + +Loads and returns an unsigned `l`-bit [`Int{:tact}`][int] from the [`Slice{:tact}`][slice] for $0 ≤$ `l` $≤ 256$. + +Attempts to specify an out-of-bounds `l` value throw an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Attempts to load more data than [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage example: + +```tact +let s: Slice = beginCell().storeUint(42, 7).asSlice(); +let fizz: Int = s.loadUint(7); +``` + +## Slice.preloadUint + +```tact +extends fun preloadUint(self: Slice, l: Int): Int; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Preloads and returns an unsigned `l`-bit [`Int{:tact}`][int] from the [`Slice{:tact}`][slice] for $0 ≤$ `l` $≤ 256$. Doesn't modify the [`Slice{:tact}`][slice]. + +Attempts to specify an out-of-bounds `l` value throw an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Attempts to preload more data than [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage example: + +```tact +let s: Slice = beginCell().storeUint(42, 7).asSlice(); +let fizz: Int = s.preloadUint(7); +``` + +## Slice.loadInt + +```tact +extends mutates fun loadInt(self: Slice, l: Int): Int; +``` + +Extension mutation function for the [`Slice{:tact}`][slice]. + +Loads and returns a signed `l`-bit [`Int{:tact}`][int] from the [`Slice{:tact}`][slice] for $0 ≤$ `l` $≤ 257$. + +Attempts to specify an out-of-bounds `l` value throw an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Attempts to load more data than [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage example: + +```tact +let s: Slice = beginCell().storeInt(42, 7).asSlice(); +let fizz: Int = s.loadInt(7); +``` + +## Slice.preloadInt + +```tact +extends fun preloadInt(self: Slice, l: Int): Int; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Preloads and returns a signed `l`-bit [`Int{:tact}`][int] from the [`Slice{:tact}`][slice] for $0 ≤$ `l` $≤ 257$. Doesn't modify the [`Slice{:tact}`][slice]. + +Attempts to specify an out-of-bounds `l` value throw an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Attempts to preload more data than [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage example: + +```tact +let s: Slice = beginCell().storeInt(42, 7).asSlice(); +let fizz: Int = s.preloadInt(7); +``` + +## Slice.loadBits + +```tact +extends mutates fun loadBits(self: Slice, l: Int): Slice; +``` + +Extension mutation function for the [`Slice{:tact}`][slice]. + +Loads $0 ≤$ `l` $≤ 1023$ bits from the [`Slice{:tact}`][slice], and returns them as a separate [`Slice{:tact}`][slice]. + +Attempts to specify an out-of-bounds `l` value throw an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Attempts to load more data than [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage example: + +```tact +let s: Slice = beginCell().storeInt(42, 7).asSlice(); +let fizz: Slice = s.loadBits(7); +``` + +## Slice.preloadBits + +```tact +extends fun preloadBits(self: Slice, l: Int): Slice; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Preloads $0 ≤$ `l` $≤ 1023$ bits from the [`Slice{:tact}`][slice], and returns them as a separate [`Slice{:tact}`][slice]. Doesn't modify the original [`Slice{:tact}`][slice]. + +Attempts to specify an out-of-bounds `l` value throw an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Attempts to preload more data than [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage example: + +```tact +let s: Slice = beginCell().storeInt(42, 7).asSlice(); +let fizz: Slice = s.preloadBits(7); +``` + +## Slice.skipBits + +```tact +extends mutates fun skipBits(self: Slice, l: Int); +``` + +Extension mutation function for the [`Slice{:tact}`][slice]. + +Loads all but the first $0 ≤$ `l` $≤ 1023$ bits from the [`Slice{:tact}`][slice]. + +Attempts to specify an out-of-bounds `l` value throw an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Attempts to load more data than [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage example: + +```tact +let s: Slice = beginCell().storeInt(42, 7).asSlice(); +s.skipBits(5); // all but first 5 bits +let fizz: Slice = s.loadBits(1); // load only 1 bit +``` + +## Slice.loadBool + +```tact +extends mutates fun loadBool(self: Slice): Bool; +``` + +Extension mutation function for the [`Slice{:tact}`][slice]. + +Loads a single bit and returns a [`Bool{:tact}`][bool] value from the [`Slice{:tact}`][slice]. Reads `true{:tact}` if the loaded bit is equal to $1$, and reads `false{:tact}` otherwise. + +Attempts to load such [`Bool{:tact}`][bool] when [`Slice{:tact}`][slice] doesn't contain it throw an exception with [exit code 8](/book/exit-codes#8): `Cell overflow`. + +Attempts to load more data than [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage example: + +```tact +let s: Slice = beginCell().storeBool(true).asSlice(); +let fizz: Bool = s.loadBool(); // true +``` + +## Slice.loadCoins + +```tact +extends mutates fun loadCoins(self: Slice): Int; +``` + +Extension mutation function for the [`Slice{:tact}`][slice]. + +Loads and returns [serialized](#builderstorecoins) an unsigned [`Int{:tact}`][int] value in the range $0 .. 2^{120} - 1$ from the [`Slice{:tact}`][slice]. This value usually represents the amount in [nanoToncoins](/book/integers#nanotoncoin). + +Attempts to load such [`Int{:tact}`][int] when [`Slice{:tact}`][slice] doesn't contain it throw an exception with [exit code 8](/book/exit-codes#8): `Cell overflow`. + +Attempts to load more data than [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage example: + +```tact +let s: Slice = beginCell().storeCoins(42).asSlice(); +let fizz: Int = s.loadCoins(); +``` + +:::note[Useful links:] + + [Special `coins` serialization type](/book/integers#serialization-coins) + +::: + +## Slice.loadAddress + +```tact +extends mutates fun loadAddress(self: Slice): Address; +``` + +Extension mutation function for the [`Slice{:tact}`][slice]. + +Loads and returns an [`Address{:tact}`][p] from the [`Slice{:tact}`][slice]. + +Attempts to load such [`Address{:tact}`][p] when [`Slice{:tact}`][slice] doesn't contain it throw an exception with [exit code 8](/book/exit-codes#8): `Cell overflow`. + +Attempts to load more data than [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage example: + +```tact +let s: Slice = beginCell().storeAddress(myAddress()).asSlice(); +let fizz: Address = s.loadAddress(); +``` + +## Slice.loadRef + +```tact +extends mutates fun loadRef(self: Slice): Cell; +``` + +Extension mutation function for the [`Slice{:tact}`][slice]. + +Loads the next reference from the [`Slice{:tact}`][slice] as a [`Cell{:tact}`][cell]. + +Attempts to load such reference [`Cell{:tact}`][cell] when [`Slice{:tact}`][slice] doesn't contain it throw an exception with [exit code 8](/book/exit-codes#8): `Cell overflow`. + +Attempts to load more data than [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage examples: + +```tact +let s: Slice = beginCell().storeRef(emptyCell()).asSlice(); +let fizz: Cell = s.loadRef(); + +let s: Slice = beginCell() + .storeRef(emptyCell()) + .storeRef(emptyCell()) + .asSlice(); +let ref1: Cell = s.loadRef(); +let ref2: Cell = s.loadRef(); +``` + +## Slice.refs + +```tact +extends fun refs(self: Slice): Int; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Returns the number of references in the [`Slice{:tact}`][slice] as an [`Int{:tact}`][int]. + +Usage example: + +```tact +let s: Slice = beginCell().storeRef(emptyCell()).asSlice(); +let fizz: Int = s.refs(); +``` + +## Slice.bits + +```tact +extends fun bits(self: Slice): Int; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Returns the number of data bits in the [`Slice{:tact}`][slice] as an [`Int{:tact}`][int]. + +Usage example: + +```tact +let s: Slice = beginCell().storeRef(emptyCell()).asSlice(); +let fizz: Int = s.bits(); +``` + +## Slice.empty + +```tact +extends fun empty(self: Slice): Bool; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Checks whether the [`Slice{:tact}`][slice] is empty (i.e., contains no bits of data and no cell references). Returns `true{:tact}` if it's empty, `false{:tact}` otherwise. + +Usage example: + +```tact +let s: Slice = beginCell().storeRef(emptyCell()).asSlice(); +let fizz: Bool = s.empty(); // false +let buzz: Bool = beginCell().asSlice().empty(); // true +``` + +:::note + + Unlike [`Slice.endParse(){:tact}`](#sliceendparse), this function doesn't throw any exceptions even when the [`Slice{:tact}`][slice] is empty. + +::: + +## Slice.dataEmpty + +```tact +extends fun dataEmpty(slice: Slice): Bool; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Checks whether the [`Slice{:tact}`][slice] has no bits of data. Returns `true{:tact}` if it has no data, `false{:tact}` otherwise. + +Usage example: + +```tact +let s: Slice = beginCell().storeRef(emptyCell()).asSlice(); +let fizz: Bool = s.dataEmpty(); // true + +let s2: Slice = beginCell().storeInt(42, 7).asSlice(); +let buzz: Bool = s2.dataEmpty(); // false +``` + +## Slice.refsEmpty + +```tact +extends fun refsEmpty(slice: Slice): Bool; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Checks whether the [`Slice{:tact}`][slice] has no references. Returns `true{:tact}` if it has no references, `false{:tact}` otherwise. + +Usage example: + +```tact +let s: Slice = beginCell().storeRef(emptyCell()).asSlice(); +let fizz: Bool = s.refsEmpty(); // false +let buzz: Bool = beginCell().asSlice().refsEmpty(); // true +``` + +## Slice.endParse + +```tact +extends fun endParse(self: Slice); +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Checks whether the [`Slice{:tact}`][slice] is empty (i.e., contains no bits of data and no cell references). If it's not, throws an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage examples: + +```tact {2,6} +let emptyOne: Slice = emptySlice(); +emptyOne.endParse(); // nothing, as it's empty + +let paul: Slice = "Fear is the mind-killer".asSlice(); +try { + paul.endParse(); // throws exit code 9 +} +``` + +## Slice.hash + +```tact +extends fun hash(self: Slice): Int; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Calculates and returns an [`Int{:tact}`][int] value of the [SHA-256][sha-2] hash of the [standard `Cell{:tact}` representation][std-repr] of the given [`Slice{:tact}`][slice]. + +Usage example: + +```tact +let s: Slice = beginCell().asSlice(); +let fizz: Int = s.hash(); +``` + +## Slice.asCell + +```tact +extends fun asCell(self: Slice): Cell; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Converts the [`Slice{:tact}`][slice] to a [`Cell{:tact}`][cell] and returns it. Alias to `beginCell().storeSlice(self).endCell(){:tact}`. + +Usage example: + +```tact +let s: Slice = beginCell().asSlice(); +let fizz: Cell = s.asCell(); +let buzz: Cell = beginCell().storeSlice(s).endCell(); + +fizz == buzz; // true +``` + +## Address.asSlice + +```tact +extends fun asSlice(self: Address): Slice; +``` + +Extension function for the [`Address{:tact}`][p]. + +Converts the [`Address{:tact}`][p] to a [`Slice{:tact}`][slice] and returns it. Alias to `beginCell().storeAddress(self).asSlice(){:tact}`. + +Usage example: + +```tact +let a: Address = myAddress(); +let fizz: Slice = a.asSlice(); +let buzz: Slice = beginCell().storeAddress(a).asSlice(); + +fizz == buzz; // true +``` + +## Struct.toCell + +```tact +extends fun toCell(self: Struct): Cell; +``` + +Extension function for any structure type [Struct][struct]. + +Converts the [Struct][struct] to a [`Cell{:tact}`][cell] and returns it. + +Usage example: + +```tact +struct GuessCoin { + probably: Int as coins; + nothing: Int as coins; +} + +fun coinCell(): Cell { + let s: GuessCoin = GuessCoin{ probably: 42, nothing: 27 }; + let fizz: Cell = s.toCell(); + + return fizz; // "x{12A11B}" +} +``` + +## Struct.fromCell + +```tact +extends fun fromCell(self: Struct, cell: Cell): Struct; +``` + +Extension function for any structure type [Struct][struct]. + +Converts a [`Cell{:tact}`][cell] into the specified [Struct][struct] and returns that [Struct][struct]. + +Attempts to pass a [`Cell{:tact}`][cell] with layout different from the specified [Struct][struct] or to load more data than a [`Cell{:tact}`][cell] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage examples: + +```tact +struct GuessCoin { + probably: Int as coins; + nothing: Int as coins; +} + +fun directParse(payload: Cell): GuessCoin { + return GuessCoin.fromCell(payload); +} + +fun cautiousParse(payload: Cell): GuessCoin? { + let coin: GuessCoin? = null; + try { + coin = GuessCoin.fromCell(payload); + } catch (e) { + dump("Cell payload doesn't match GuessCoin Struct!"); + } + return coin; +} +``` + +## Struct.fromSlice + +```tact +extends fun fromSlice(self: Struct, cell: Slice): Struct; +``` + +Extension function for any structure type [Struct][struct]. + +Converts a [`Slice{:tact}`][slice] into the specified [Struct][struct] and returns that [Struct][struct]. + +Attempts to pass a [`Slice{:tact}`][slice] with layout different from the specified [Struct][struct] or to load more data than a [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage examples: + +```tact +struct GuessCoin { + probably: Int as coins; + nothing: Int as coins; +} + +fun directParse(payload: Slice): GuessCoin { + return GuessCoin.fromSlice(payload); +} + +fun cautiousParse(payload: Slice): GuessCoin? { + let coin: GuessCoin? = null; + try { + coin = GuessCoin.fromSlice(payload); + } catch (e) { + dump("Slice payload doesn't match GuessCoin Struct!"); + } + return coin; +} +``` + +## Message.toCell + +```tact +extends fun toCell(self: Message): Cell; +``` + +Extension function for any message type [Message][message]. + +Converts the [Message][message] to a [`Cell{:tact}`][cell] and returns it. + +Usage example: + +```tact +message GuessCoin { + probably: Int as coins; + nothing: Int as coins; +} + +fun coinCell(): Cell { + let s: GuessCoin = GuessCoin{ probably: 42, nothing: 27 }; + let fizz: Cell = s.toCell(); + + return fizz; // "x{AB37107712A11B}" +} +``` + +## Message.fromCell + +```tact +extends fun fromCell(self: Message, cell: Cell): Message; +``` + +Extension function for any message type [Message][message]. + +Converts a [`Cell{:tact}`][cell] into the specified [Message][message] and returns that [Message][message]. + +Attempts to pass a [`Cell{:tact}`][cell] with layout different from the specified [Message][message] or to load more data than a [`Cell{:tact}`][cell] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage examples: + +```tact +message(0x777) TripleAxe { + prize: Int as uint32; +} + +fun directParse(payload: Cell): TripleAxe { + return TripleAxe.fromCell(payload); +} + +fun cautiousParse(payload: Cell): TripleAxe? { + let coin: TripleAxe? = null; + try { + coin = TripleAxe.fromCell(payload); + } catch (e) { + dump("Cell payload doesn't match TripleAxe Message!"); + } + return coin; +} +``` + +## Message.fromSlice + + +```tact +extends fun fromSlice(self: Message, cell: Slice): Message; +``` + +Extension function for any message type [Message][message]. + +Converts a [`Slice{:tact}`][slice] into the specified [Message][message] and returns that [Message][message]. + +Attempts to pass a [`Slice{:tact}`][slice] with layout different from the specified [Message][message] or to load more data than a [`Slice{:tact}`][slice] contains throw an exception with [exit code 9](/book/exit-codes#9): `Cell underflow`. + +Usage examples: + +```tact +message(0x777) TripleAxe { + prize: Int as uint32; +} + +fun directParse(payload: Slice): TripleAxe { + return TripleAxe.fromSlice(payload); +} + +fun cautiousParse(payload: Slice): TripleAxe? { + let coin: TripleAxe? = null; + try { + coin = TripleAxe.fromSlice(payload); + } catch (e) { + dump("Slice payload doesn't match TripleAxe Message!"); + } + return coin; +} +``` + +[p]: /book/types#primitive-types +[bool]: /book/types#booleans +[int]: /book/integers +[cell]: /book/cells#cells +[builder]: /book/cells#builders +[slice]: /book/cells#slices +[map]: /book/maps +[struct]: /book/structs-and-messages#structs +[message]: /book/structs-and-messages#messages + +[std-repr]: /book/cells#cells-representation + +[tlb]: https://docs.ton.org/develop/data-formats/tl-b-language +[sha-2]: https://en.wikipedia.org/wiki/SHA-2#Hash_standard diff --git a/docs/src/content/docs/ref/core-common.mdx b/docs/src/content/docs/ref/core-common.mdx new file mode 100644 index 000000000..06be1b7ca --- /dev/null +++ b/docs/src/content/docs/ref/core-common.mdx @@ -0,0 +1,245 @@ +--- +title: Common +--- + +List of the most commonly used built-in [global static functions](/book/functions#global-static-functions). + +## Contextual + +### now + +```tact +fun now(): Int +``` + +Returns the current [Unix time](https://en.wikipedia.org/wiki/Unix_time). + +Usage example: + +```tact +let timeOffset: Int = now() + 1000; // thousand seconds from now() +``` + +### myBalance + +```tact +fun myBalance(): Int; +``` + +Returns the [nanoToncoin](/book/integers#nanotoncoin) balance of the smart contract as it was at the start of the [compute phase](https://docs.ton.org/learn/tvm-instructions/tvm-overview#compute-phase) of the current transaction. + +Usage example: + +```tact +let iNeedADolla: Int = myBalance(); +``` + +:::caution + + Beware, that [all message sending functions](/book/send) of Tact can change the _actual_ contract's balance, but they _won't_ update the value returned by this function. + +::: + +### myAddress + +```tact +fun myAddress(): Address; +``` + +Returns the address of the current smart contract as an [`Address{:tact}`][p]. + +Usage example: + +```tact +let meMyselfAndI: Address = myAddress(); +``` + +### sender + +```tact +fun sender(): Address; +``` + +Returns the [`Address{:tact}`][p] of the sender of the current message. + +Usage example: + +```tact +receive() { + let whoSentMeMessage: Address = sender(); +} +``` + +:::caution + + Behavior is undefined for [getter functions](/book/contracts#getter-functions), as they cannot have a sender nor they can send messages. + +::: + +:::note + + In order to reduce gas usage, prefer using this function over calling [`context().sender{:tact}`](#context) when you only need to know the sender of the message. + +::: + +### context + +```tact +fun context(): Context; +``` + +Returns `Context{:tact}` [Struct](/book/structs-and-messages#structs), that consists of: + +Field | Type | Description +:-------- | :-------------------- | :---------- +`bounced` | [`Bool{:tact}`][bool] | [Bounced](https://ton.org/docs/learn/overviews/addresses#bounceable-vs-non-bounceable-addresses) flag of the incoming message. +`sender` | [`Address{:tact}`][p] | Internal address of the sender on the TON blockchain. +`value` | [`Int{:tact}`][int] | Amount of [nanoToncoins](/book/integers#nanotoncoin) in a message. +`raw` | [`Slice{:tact}`][slice] | The remainder of the message as a [`Slice{:tact}`][slice]. It follows [internal message layout](https://docs.ton.org/develop/smart-contracts/messages#message-layout) of TON starting from the destination [`Address{:tact}`][p] (`dest:MsgAddressInt ` in [TL-B notation](https://docs.ton.org/develop/data-formats/tl-b-language)). + +Usage example: + +```tact +let ctx: Context = context(); +require(ctx.value != 68 + 1, "Invalid amount of nanoToncoins, bye!"); +``` + +:::note + + Note, that if you only need to know who sent the message, use the [`sender(){:tact}`](#sender) function, as it's less gas-consuming. + +::: + +## Addressing + +### newAddress + +```tact +fun newAddress(chain: Int, hash: Int): Address; +``` + +Creates a new [`Address{:tact}`][p] based on the [`chain` id](https://ton-blockchain.github.io/docs/#/overviews/TON_blockchain_overview) and the [SHA-256](/ref/core-math#sha256) encoded [`hash` value](https://docs.ton.org/learn/overviews/addresses#account-id). + +This function tries to resolve constant values in [compile-time](/ref/core-comptime) whenever possible. + +Usage example: + +```tact +let oldTonFoundationAddr: Address = + newAddress(0, 0x83dfd552e63729b472fcbcc8c45ebcc6691702558b68ec7527e1ba403a0f31a8); + // ↑ ------------------------------------------------------------------ + // | ↑ + // | sha-256 hash of contract's init package (StateInit) + // chain id: 0 is a workchain, -1 is a masterchain +``` + +:::caution + + This method throws an error with [exit code 136](/book/exit-codes#136) if `chain` is invalid or with [exit code 137](/book/exit-codes#137) if `chain` points to the masterchain ($-1$) without [masterchain support](/book/masterchain) enabled. + +::: + +:::note[Useful links:] + + [`chain` (Workchain ID) in TON Docs](https://docs.ton.org/learn/overviews/addresses#workchain-id)\ + [`hash` (Account ID) in TON Docs](https://docs.ton.org/learn/overviews/addresses#account-id)\ + [Contract's init package (`StateInit{:tact}`)](/book/expressions#initof) + +::: + +### contractAddress + +```tact +fun contractAddress(s: StateInit): Address; +``` + +Computes smart contract's [`Address{:tact}`][p] in a workchain $0$ based on its [`StateInit{:tact}`](/book/expressions#initof). + +Usage example: + +```tact +let foundMeSome: Address = contractAddress(initOf SomeContract()); +``` + +### contractAddressExt + +```tact +fun contractAddressExt(chain: Int, code: Cell, data: Cell): Address; +``` + +Computes smart contract's [`Address{:tact}`][p] based on the `chain` id, contract's `code` and contract's initial state `data`. Use [`initOf{:tact}`](/book/expressions#initof) expression to obtain initial `code` and initial `data` of a given contract. + +Usage example: + +```tact +let initPkg: StateInit = initOf SomeContract(); +let hereBeDragons: Address = contractAddressExt(0, initPkg.code, initPkg.data); +``` + +:::caution + + This method throws an error with [exit code 136](/book/exit-codes#136) if `chain` is invalid or with [exit code 137](/book/exit-codes#137) if `chain` points to the masterchain ($-1$) without [masterchain support](/book/masterchain) enabled. + +::: + +:::note + + For this function to work, the compiler option `debug` has to be set to `true{:tact}` for the current project in the [configuration file](/book/config).\ + Read more about debugging on the dedicated page: [Debugging](/book/debug). + +::: + +## Communication + +### send + +```tact +fun send(params: SendParameters); +``` + +[Queues the message](/book/send#outbound-message-processing) to be sent using a [`SendParameters{:tact}`](/book/send) [Struct](/book/structs-and-messages#structs). + +Usage example: + +```tact +send(SendParameters{ + to: sender(), // back to the sender, + value: ton("1"), // with 1 Toncoin (1_000_000_000 nanoToncoin), + // and no message body +}); +``` + +:::note[Useful links:] + + [Sending messages in the Book](/book/send)\ + [Message `mode` in the Book](/book/message-mode)\ + [Single-contract communication in the Cookbook](/cookbook/single-communication) + +::: + +### emit + +```tact +fun emit(body: Cell); +``` + +[Queues the message](/book/send#outbound-message-processing) `body` to be sent to the outer world with the purpose of logging and analyzing it later off-chain. The message does not have a recipient and is gas-efficient compared to using any other message sending functions of Tact. + +Usage example: + +```tact +emit("Catch me if you can, Mr. Holmes".asComment()); // asComment() converts a String to a Cell +``` + +:::note + + To analyze `emit(){:tact}` calls, one has to look at [external messages](/book/external) produced by the contract. + + Read more: [Logging via `emit(){:tact}`](/book/debug#logging). + +::: + +[p]: /book/types#primitive-types +[bool]: /book/types#booleans +[int]: /book/integers +[slice]: /book/cells#slices diff --git a/docs/src/content/docs/ref/core-comptime.mdx b/docs/src/content/docs/ref/core-comptime.mdx new file mode 100644 index 000000000..f37459a08 --- /dev/null +++ b/docs/src/content/docs/ref/core-comptime.mdx @@ -0,0 +1,73 @@ +--- +title: Compile-time +--- + +This page lists all the built-in [global static functions](/book/functions#global-static-functions), which are evaluated at the time of building the Tact project and cannot work with non-constant, run-time data. These functions are commonly referred to as "compile-time functions". + +## address + +```tact +fun address(s: String): Address; +``` + +A compile-time function that converts a [`String{:tact}`][p] with an address into the [`Address{:tact}`][p] type. + +Usage example: + +```tact +contract Example { + // Persistent state variables + addr: Address = + address("EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N"); // works at compile-time! +} +``` + +## cell + +```tact +fun cell(bocBase64: String): Cell; +``` + +A compile-time function that embeds a base64-encoded [BoC](https://docs.ton.org/develop/data-formats/cell-boc#bag-of-cells) `bocBase64` as a [`Cell{:tact}`][cell] into the contract. + +Usage example: + +```tact +contract Example { + // Persistent state variables + storedCell: Cell = + // Init package for Wallet V3R1 as a base64-encoded BoC + cell("te6cckEBAQEAYgAAwP8AIN0gggFMl7qXMO1E0NcLH+Ck8mCDCNcYINMf0x/TH/gjE7vyY+1E0NMf0x/T/9FRMrryoVFEuvKiBPkBVBBV+RDyo/gAkyDXSpbTB9QC+wDo0QGkyMsfyx/L/8ntVD++buA="); // works at compile-time! +} +``` + +:::note[Useful links:] + + [Bag of Cells in TON Docs](https://docs.ton.org/develop/data-formats/cell-boc#bag-of-cells) + +::: + +## ton + +```tact +fun ton(value: String): Int; +``` + +A compile-time function that converts the given Toncoins `value` from a human-readable format [`String{:tact}`][p] to the [nanoToncoin](/book/integers#nanotoncoin) [`Int{:tact}`][int] format. + +Usage example: + +```tact +contract Example { + // Persistent state variables + one: Int = ton("1"); // 10^9 nanoToncoins, which is equal to one Toncoin + pointOne: Int = ton("0.1"); // 10^8 nanoToncoins, which is equal to 0.1 Toncoin + nano: Int = ton("0.000000001"); // 1 nanoToncoin, which is equal to 10^-9 Toncoins + // works at compile-time! +} +``` + +[p]: /book/types#primitive-types +[bool]: /book/types#booleans +[int]: /book/integers +[cell]: /book/cells#cells diff --git a/docs/src/content/docs/ref/core-debug.mdx b/docs/src/content/docs/ref/core-debug.mdx new file mode 100644 index 000000000..3c80496a8 --- /dev/null +++ b/docs/src/content/docs/ref/core-debug.mdx @@ -0,0 +1,217 @@ +--- +title: Debug +--- + +List of functions commonly used for debugging smart contracts in Tact. + +:::note + + Read more about debugging on the dedicated page: [Debugging](/book/debug). + +::: + +## require + +```tact +fun require(condition: Bool, error: String); +``` + +Checks the `condition` and throws an error with an [exit code](/book/exit-codes) generated from the `error` message if the `condition` is `false{:tact}`. Does nothing otherwise. + +The algorithm for generating the exit code works as follows: + +* First, the [SHA-256](https://en.wikipedia.org/wiki/SHA-2#Hash_standard) hash of `error` message [`String{:tact}`][p] is obtained. +* Then, its value is read as a 32-bit [big-endian](https://en.wikipedia.org/wiki/Endianness) number modulo $63000$ plus $1000$, in that order. +* Finally, it's put into the `.md` compilation report file, which resides with the other compilation artifacts in your project's `outputs/` or `build/` directories. + +The generated exit code is guaranteed to be outside the common $0 - 255$ range reserved for TVM and Tact contract errors, which makes it possible to distinguish exit codes from `require(){:tact}` and any other [standard exit codes](/book/exit-codes). + +Usage examples: + +```tact +// now() has to return a value greater than 1000, otherwise an error message will be thrown +require(now() > 1000, "We're in the first 1000 seconds of 1 January 1970!"); + +try { + // The following will never be true, so this require would always throw + require(now() < -1, "Time is an illusion. Lunchtime doubly so."); +} catch (e) { + // e will be outside of range 0-255 + dump(e); +} +``` + +## dump + +```tact +fun dump(arg); +``` + +Prints the argument `arg` to the contract's debug console. Evaluated only if the `debug` option in the [configuration file](/book/config) is set to `true{:json}`, otherwise does nothing. + +Can be applied to the following list of types and values: + +* [`Int{:tact}`][int] +* [`Bool{:tact}`][bool] +* [`Address{:tact}`][p] +* [`Cell{:tact}`][cell], [`Builder{:tact}`][builder] or [`Slice{:tact}`][slice] +* [`String{:tact}`][p] or [`StringBuilder{:tact}`][p] +* [`map{:tact}`](/book/maps) +* [Optionals and `null{:tact}` value](/book/optionals) +* `void`, which is implicitly returned when a function doesn't have return value defined + +Usage examples: + +```tact +// Int +dump(42); + +// Bool +dump(true); +dump(false); + +// Address +dump(myAddress()); + +// Cell, Builder or Slice +dump(emptyCell()); // Cell +dump(beginCell()); // Builder +dump(emptySlice()); // Slice + +// String or StringBuilder +dump("Hello, my name is..."); // String +dump(beginTailString()); // StringBuilder + +// Maps +let m: map = emptyMap(); +m.set(2 + 2, 4); +dump(m); + +// Special values +dump(null); +dump(emit("msg".asComment())); // As emit() function doesn't return a value, dump() would print #DEBUG#: void. +``` + +:::note[Useful links:] + + [Debug with `dump(){:tact}`](/book/debug#tests-dump) + +::: + +## dumpStack + +```tact +fun dumpStack(); +``` + +Prints all the values of [persistent state variables](/book/contracts#variables) to the contract's debug console. Evaluated only if the `debug` option in the [configuration file](/book/config) is set to `true{:json}`, otherwise does nothing. + +Usage example: + +```tact {6} +contract DumpsterFire { + var1: Int = 0; + var2: Int = 5; + + receive() { + dumpStack(); // would print 0 5 + } +} +``` + +:::note[Useful links:] + + [Debug with `dump(){:tact}`](/book/debug#tests-dump) + +::: + +## throw + +```tact +fun throw(code: Int); +``` + +An alias to [`nativeThrow(){:tact}`](#nativethrow). + +## nativeThrow + +```tact +fun nativeThrow(code: Int); +```` + +Throws an exception with an error code equal to `code`. Execution of the current context stops (the statements after `nativeThrow` won't be executed) and control will be passed to the first [`try...catch{:tact}` block](/book/statements#try-catch) in the call stack. If no `try{:tact}` or `try...catch{:tact}` block exists among caller functions, [TVM](https://docs.ton.org/learn/tvm-instructions/tvm-overview) will terminate the transaction. + +Attempts to specify the `code` outside of $0 - 65535$ range cause an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Usage examples: + +```tact {2,7} +fun thisWillTerminate() { + nativeThrow(42); // throwing with exit code 42 +} + +fun butThisDoesNot() { + try { + nativeThrow(42); // throwing with exit code 42 + } + + // ... follow-up logic ... +} +``` + +## nativeThrowIf + +```tact +fun nativeThrowIf(code: Int, condition: Bool); +``` + +Similar to [`nativeThrow(){:tact}`](#nativethrow), but throws an exception conditionally, when `condition` is equal to `true{:tact}`. Doesn't throw otherwise. + +Attempts to specify the `code` outside of $0 - 65535$ range cause an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Usage examples: + +```tact {2,7} +fun thisWillTerminate() { + nativeThrowIf(42, true); // throwing with exit code 42 +} + +fun butThisDoesNot() { + try { + nativeThrowIf(42, true); // throwing with exit code 42 + } + // ... follow-up logic ... +} +``` + +## nativeThrowUnless + +```tact +fun nativeThrowUnless(code: Int, condition: Bool); +``` + +Similar to [`nativeThrow(){:tact}`](#nativethrow), but throws an exception conditionally, when `condition` is equal to `false{:tact}`. Doesn't throw otherwise. + +Attempts to specify the `code` outside of $0 - 65535$ range cause an exception with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Usage examples: + +```tact {2,7} +fun thisWillTerminate() { + nativeThrowUnless(42, false); // throwing with exit code 42 +} + +fun butThisDoesNot() { + try { + nativeThrowUnless(42, false); // throwing with exit code 42 + } + // ... follow-up logic ... +} +``` + +[p]: /book/types#primitive-types +[bool]: /book/types#booleans +[int]: /book/integers +[cell]: /book/cells#cells +[builder]: /book/cells#builders +[slice]: /book/cells#slices diff --git a/docs/src/content/docs/ref/core-math.mdx b/docs/src/content/docs/ref/core-math.mdx new file mode 100644 index 000000000..6e6a36714 --- /dev/null +++ b/docs/src/content/docs/ref/core-math.mdx @@ -0,0 +1,280 @@ +--- +title: Math +--- + +Various math helper functions. + +## min + +```tact +fun min(x: Int, y: Int): Int; +``` + +Computes and returns the [minimum](https://en.wikipedia.org/wiki/Maximum_and_minimum) of two [`Int{:tact}`][int] values `x` and `y`. + +Usage examples: + +```tact +min(1, 2); // 1 +min(2, 2); // 2 +min(007, 3); // 3 +min(0x45, 3_0_0); // 69, nice +// ↑ ↑ +// 69 300 +``` + +## max + +```tact +fun max(x: Int, y: Int): Int; +``` + +Computes and returns the [maximum](https://en.wikipedia.org/wiki/Maximum_and_minimum) of two [`Int{:tact}`][int] values `x` and `y`. + +Usage examples: + +```tact +max(1, 2); // 2 +max(2, 2); // 2 +max(007, 3); // 7 +max(0x45, 3_0_0); // 300 +// ↑ ↑ +// 69 300 +``` + +## abs + +```tact +fun abs(x: Int): Int +``` + +Computes and returns the [absolute value](https://en.wikipedia.org/wiki/Absolute_value) of the [`Int{:tact}`][int] value `x`. + +Usage examples: + +```tact +abs(42); // 42 +abs(-42); // 42 +abs(-(-(-42))); // 42 +``` + +## log + +```tact +fun log(num: Int, base: Int): Int; +``` + +Computes and returns the [logarithm](https://en.wikipedia.org/wiki/Logarithm) of a number `num` $> 0$ to the base `base` $≥ 1$. Results are [rounded down](https://en.wikipedia.org/wiki/Rounding#Rounding_down). Passing a non-positive `num` value or a `base` less than $1$ throws an error with [exit code 5](/book/exit-codes#5): `Integer out of expected range`. + +Usage examples: + +```tact +log(1000, 10); // 3, as 10^3 is 1000 +// ↑ ↑ ↑ ↑ +// num base base num + +log(1001, 10); // 3 +log(999, 10); // 2 +try { + log(-1000, 10); // throws exit code 5 because of the non-positive num +} +log(1024, 2); // 10 +try { + log(1024, -2); // throws exit code 5 because of the base less than 1 +} +``` + +:::note + + Note, that if you only need to obtain logarithms to the base $2$, use the [`log2(){:tact}`](#log2) function, as it's more gas-efficient. + +::: + +## log2 + +```tact +fun log2(num: Int): Int; +``` + +Similar to [`log(){:tact}`](#log), but sets the `base` to $2$. + +Usage example: + +```tact +log2(1024); // 10, as 2^10 is 1024 +// ↑ ↑ ↑ +// num base₂ num +``` + +:::note + + In order to reduce gas usage, prefer using this function over calling [`log(){:tact}`](#log) when you only need to obtain logarithms to the base $2$. + +::: + +## pow + +```tact +fun pow(base: Int, exp: Int): Int; +``` + +Computes and returns the [exponentiation](https://en.wikipedia.org/wiki/Exponentiation) involving two numbers: the `base` and the exponent (or _power_) `exp`. Exponent `exp` must be non-negative, otherwise an error with [exit code 5](/book/exit-codes#5) will be thrown: `Integer out of expected range`. + +Note, that this function works both at run-time and at [compile-time](/ref/core-comptime). + +Usage example: + +```tact +contract Example { + // Persistent state variables + p23: Int = pow(2, 3); // raises 2 to the 3rd power, which is 8 + one: Int = pow(5, 0); // raises 5 to the power 0, which always produces 1 + // works at compile-time! + + // Internal message receiver, which accepts message ExtMsg + receive() { + pow(self.p23, self.one + 1); // 64, works at run-time too! + pow(0, -1); // ERROR! Exit code 5: Integer out of expected range + } +} +``` + +:::note + + Note, that if you only need to obtain powers of $2$, use the [`pow2(){:tact}`](#pow2) function, as it's more gas-efficient. + +::: + +:::note + + List of functions, that only work at compile-time: [API Comptime](/ref/core-comptime). + +::: + +## pow2 + +```tact +fun pow2(exp: Int): Int; +``` + +Similar to [`pow(){:tact}`](#pow), but sets the `base` to $2$. Works both at run-time and at [compile-time](/ref/core-comptime). + +Usage examples: + +```tact +contract Example { + // Persistent state variables + p23: Int = pow2(3); // raises 2 to the 3rd power, which is 8 + one: Int = pow2(0); // raises 2 to the power 0, which always produces 1 + // works at compile-time! + + // Internal message receiver, which accepts message ExtMsg + receive() { + pow2(self.one + 1); // 4, works at run-time too! + pow2(-1); // ERROR! Exit code 5: Integer out of expected range + } +} +``` + +:::note + + In order to reduce gas usage, prefer using this function over calling [`pow(){:tact}`](#pow) when you only need to obtain powers of $2$. + +::: + +:::note + + List of functions, that only work at compile-time: [API Comptime](/ref/core-comptime). + +::: + +## checkSignature + +```tact +fun checkSignature(hash: Int, signature: Slice, public_key: Int): Bool; +``` + +Checks the [Ed25519][ed] `signature` of the $256$-bit unsigned [`Int{:tact}`][int] `hash` using a `public_key`, represented by a $256$-bit unsigned [`Int{:tact}`][int] too. The signature must contain at least $512$ bits of data, but only the first $512$ bits are used. + +Returns `true{:tact}` if the signature is valid, `false{:tact}` otherwise. + +Usage example: + +```tact {19-24} +message ExtMsg { + signature: Slice; + data: Cell; +} + +contract Showcase { + // Persistent state variables + pub: Int as uint256; // public key as an 256-bit unsigned Int + + // Constructor function init(), where all the variables are initialized + init(pub: Int) { + self.pub = pub; // storing the public key upon contract initialization + } + + // External message receiver, which accepts message ExtMsg + external(msg: ExtMsg) { + let hash: Int = beginCell().storeRef(msg.data).endCell().hash(); + let check: Bool = checkSignature(hash, msg.signature, self.pub); + // ---- ------------- -------- + // ↑ ↑ ↑ + // | | public_key, stored in our contract + // | signature, obtained from the received message + // hash, calculated using the data from the received message + // ... follow-up logic ... + } +} +``` + +## checkDataSignature + +```tact +fun checkDataSignature(data: Slice, signature: Slice, public_key: Int): Bool; +``` + +Checks the [Ed25519][ed] `signature` of the `data` using a `public_key`, similar to [`checkSignature(){:tact}`](#checksignature). If the bit length of `data` is not divisible by $8$, this functions throws an error with [exit code 9](/book/exit-codes#9): `Cell underflow`. Verification itself is being done indirectly: on a [SHA-256][sha-2] hash of the `data`. + +Returns `true{:tact}` if the signature is valid, `false{:tact}` otherwise. + +Usage example: + +```tact +let data: Slice = ...; +let signature: Slice = ...; +let publicKey: Int = ...; + +let check: Bool = checkSignature(data, signature, publicKey); +``` + +## sha256 + +```tact +fun sha256(data: Slice): Int; +fun sha256(data: String): Int; +``` + +Computes and returns the [SHA-256][sha-2] hash as an $256$-bit unsigned [`Int{:tact}`][int] from a passed [`Slice{:tact}`][slice] or [`String{:tact}`][p] `data`. + +In case `data` is a [`String{:tact}`][p] it should have a number of bits divisible by $8$, and in case it's a [`Slice{:tact}`][slice] it must **also** have no references (i.e. only up to 1023 bits of data in total). + +This function tries to resolve constant string values in [compile-time](/ref/core-comptime) whenever possible. + +Usage examples: + +```tact +sha256(beginCell().asSlice()); +sha256("Hello, world!"); // will be resolved in compile-time +sha256(someVariableElsewhere); // will try to resolve at compile-time, + // and fallback to run-time evaluation +``` + +[p]: /book/types#primitive-types +[bool]: /book/types#booleans +[int]: /book/integers +[slice]: /book/cells#slices + +[ed]: https://en.wikipedia.org/wiki/EdDSA#Ed25519 +[sha-2]: https://en.wikipedia.org/wiki/SHA-2#Hash_standard diff --git a/docs/src/content/docs/ref/core-random.mdx b/docs/src/content/docs/ref/core-random.mdx new file mode 100644 index 000000000..c0aa93f2e --- /dev/null +++ b/docs/src/content/docs/ref/core-random.mdx @@ -0,0 +1,44 @@ +--- +title: Random number generation +--- + +Random number generation for Tact smart contracts. + +## random + +```tact +fun random(min: Int, max: Int): Int; +``` + +Generates and returns a new pseudo-random unsigned [`Int{:tact}`][int] value `x` in the provided semi-closed interval: `min` $≤$ `x` $<$ `max` or `min` $≥$ `x` $>$ `max`, if both `min` and `max` are negative. Note, that `max` value is never included in the interval. + +Usage examples: + +```tact +random(42, 43); // 42, always +random(0, 42); // 0-41, but never a 42 +``` + +## randomInt + +```tact +fun randomInt(): Int; +``` + +Generates and returns a new pseudo-random unsigned $256$-bit [`Int{:tact}`][int] value `x`. + +The algorithm works as follows: if `r` is the old value of the random seed considered a $32$-byte array (by constructing the big-endian representation of an unsigned $256$-bit [`Int{:tact}`][int]), then its `sha512(r){:tact}` is computed. The first $32$ bytes of this hash are stored as the new value `r'` of the random seed, and the remaining $32$ bytes are returned as the next random value `x`. + +Usage example: + +```tact +let allYourRandomBelongsToUs: Int = randomInt(); // ???, it's random :) +``` + +:::caution + + Advanced functions for working with random numbers are listed on a specialized page: [Advanced APIs](/ref/core-advanced). + +::: + +[int]: /book/integers diff --git a/docs/src/content/docs/ref/core-strings.mdx b/docs/src/content/docs/ref/core-strings.mdx new file mode 100644 index 000000000..ef4fcaff2 --- /dev/null +++ b/docs/src/content/docs/ref/core-strings.mdx @@ -0,0 +1,354 @@ +--- +title: Strings and StringBuilders +--- + +Strings are immutable sequences of characters, which means that once a [`String{:tact}`][p] is created, it cannot be changed. Strings are useful to store text, and so they can be converted to [`Cell{:tact}`][cell] type to be used as message bodies. + +To be able to concatenate strings in a gas-efficient way, use a [`StringBuilder{:tact}`][p]. + +To use [`String{:tact}`][p] literals directly, see: [String literals](/book/expressions#string-literals). + +## beginString + +```tact +fun beginString(): StringBuilder; +``` + +Creates and returns an empty [`StringBuilder{:tact}`][p]. + +Usage example: + +```tact +let fizz: StringBuilder = beginString(); +``` + +## beginComment + +```tact +fun beginComment(): StringBuilder; +``` + +Creates and returns an empty [`StringBuilder{:tact}`][p] for building a comment string, which prefixes the resulting [`String{:tact}`][p] with four null bytes. This format is used for passing text comments as message bodies. + +Usage example: + +```tact +let fizz: StringBuilder = beginComment(); +``` + +## beginTailString + +```tact +fun beginTailString(): StringBuilder; +``` + +Creates and returns an empty [`StringBuilder{:tact}`][p] for building a tail string, which prefixes the resulting [`String{:tact}`][p] with a single null byte. This format is used in various standards like NFT or Jetton. + +Usage example: + +```tact +let fizz: StringBuilder = beginTailString(); +``` + +## beginStringFromBuilder + +```tact +fun beginStringFromBuilder(b: StringBuilder): StringBuilder; +``` + +Creates and returns a new [`StringBuilder{:tact}`][p] from existing [`StringBuilder{:tact}`][p] `b`. Useful when you need to serialize an existing [`String{:tact}`][p] to a [`Cell{:tact}`][cell] with some other data. + +Usage example: + +```tact +let fizz: StringBuilder = beginStringFromBuilder(beginString()); +``` + +## StringBuilder.append + +```tact +extends mutates fun append(self: StringBuilder, s: String); +``` + +Extension mutation function for the [`StringBuilder{:tact}`][p]. + +Appends a [`String{:tact}`][p] `s` to the [`StringBuilder{:tact}`][p]. + +Usage example: + +```tact +let fizz: StringBuilder = beginString(); +fizz.append("oh"); +fizz.append("my"); +fizz.append("Tact!"); +``` + +## StringBuilder.concat + +```tact +extends fun concat(self: StringBuilder, s: String): StringBuilder; +``` + +Extension function for the [`StringBuilder{:tact}`][p]. + +Returns a new [`StringBuilder{:tact}`][p] after concatinating it with a [`String{:tact}`][p] `s`. Can be chained, unlike [`StringBuilder.append(){:tact}`](#stringbuilderappend). + +Usage example: + +```tact +let fizz: StringBuilder = beginString() + .concat("oh") + .concat("my") + .concat("Tact!"); +``` + +## StringBuilder.toString + +```tact +extends fun toString(self: StringBuilder): String; +``` + +Extension function for the [`StringBuilder{:tact}`][p]. + +Returns a built [`String{:tact}`][p] from a [`StringBuilder{:tact}`][p]. + +Usage example: + +```tact +let fizz: StringBuilder = beginString(); +let buzz: String = fizz.toString(); +``` + +## StringBuilder.toCell + +```tact +extends fun toCell(self: StringBuilder): Cell; +``` + +Extension function for the [`StringBuilder{:tact}`][p]. + +Returns an assembled [`Cell{:tact}`][cell] from a [`StringBuilder{:tact}`][p]. + +Usage example: + +```tact +let fizz: StringBuilder = beginString(); +let buzz: Cell = fizz.toCell(); +``` + +## StringBuilder.toSlice + +```tact +extends fun toSlice(self: StringBuilder): Slice; +``` + +Extension function for the [`StringBuilder{:tact}`][p]. + +Returns an assembled [`Cell{:tact}`][cell] as a [`Slice{:tact}`][slice] from a [`StringBuilder{:tact}`][p]. Alias to [`self.toCell().asSlice(){:tact}`](/ref/core-cells#cellasslice). + +Usage example: + +```tact +let s: StringBuilder = beginString(); +let fizz: Slice = s.toSlice(); +let buzz: Slice = s.toCell().asSlice(); + +fizz == buzz; // true +``` + +## String.asSlice + +```tact +extends fun asSlice(self: String): Slice; +``` + +Extension function for the [`String{:tact}`][p]. + +Returns a [`Slice{:tact}`][slice] from a [`String{:tact}`][p] by trying to pack all of its bits into a continuous list of [Cells][p], each referencing the next one and opening them all for future parsing. + +Note, that there's no indication of how many bytes a particular character could take in the [`Slice{:tact}`][slice] or how deep the list of references is going to be, so use this function only if you know what you're doing. + +Usage example: + +```tact +let s: String = "It's alive! It's alive!!!"; +let fizz: Slice = s.asSlice(); +let buzz: Slice = s.asSlice().asString().asSlice(); + +fizz == buzz; // true, but be careful as it's not always the case +``` + +:::note + + See how `String.asSlice{:tact}` function can be used in practice: [How to convert a `String` to an `Int`](/cookbook/type-conversion#how-to-convert-a-string-to-an-int). + +::: + +## String.asComment + +```tact +extends fun asComment(self: String): Cell; +``` + +Extension function for the [`String{:tact}`][p]. + +Returns a [`Cell{:tact}`][cell] from a [`String{:tact}`][p] by prefixing the latter with four null bytes. This format is used for passing text comments as message bodies. + +Usage example: + +```tact +let s: String = "When life gives you lemons, call them 'yellow oranges' and sell them for double the price."; +let fizz: Cell = s.asComment(); + +let b: StringBuilder = beginComment(); +b.append(s); +let buzz: Cell = b.toCell(); + +fizz == buzz; // true +``` + +## String.fromBase64 + +```tact +extends fun fromBase64(self: String): Slice; +``` + +Extension function for the [`String{:tact}`][p]. + +Returns a [`Slice{:tact}`][slice] out of the decoded [Base64](https://en.wikipedia.org/wiki/Base64) [`String{:tact}`][p]. Alias to `self.asSlice().fromBase64(){:tact}`. + +Note, that this function is limited and only takes the first $1023$ bits of data from the given [`String{:tact}`][p], without throwing an exception when the [`String{:tact}`][p] is larger (i.e. contains more than $1023$ bits of data). + +If the given [`String{:tact}`][p] contains characters not from the Base64 set, an exception with [exit code 134](/book/exit-codes#134) will be thrown: `Invalid argument`. + +Usage example: + +```tact +let s: String = "SGVyZSdzIEpvaG5ueSE="; +let fizz: Slice = s.fromBase64(); +let buzz: Slice = s.asSlice().fromBase64(); + +fizz == buzz; // true +``` + +## Slice.asString + +```tact +extends fun asString(self: Slice): String; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Returns a [`String{:tact}`][p] from a [`Slice{:tact}`][slice] by trying to load all of its bits without looking for its references, if any. + +Note, that this function doesn't look at the references at all and is truncates its output to $1023$ bits, so use it only if you know what you're doing. + +Usage example: + +```tact +let s: String = "Keep your Slices close, but your Strings closer."; +let fizz: String = s; +let buzz: String = s.asSlice().asString(); + +fizz == buzz; // true, but be careful as it's not always the case +``` + +## Slice.fromBase64 + +```tact +extends fun fromBase64(self: Slice): Slice; +``` + +Extension function for the [`Slice{:tact}`][slice]. + +Returns a new [`Slice{:tact}`][slice] out of the decoded [Base64](https://en.wikipedia.org/wiki/Base64) [`Slice{:tact}`][slice]. + +Note, that this function is limited and only takes the first $1023$ bits of data from the given [`Slice{:tact}`][slice], without throwing an exception if the [`Slice{:tact}`][slice] has more data (i.e., when it has any references). + +If the given [`Slice{:tact}`][p] contains characters not from the Base64 set, an exception with [exit code 134](/book/exit-codes#134) will be thrown: `Invalid argument`. + +Usage example: + +```tact +let s: Slice = "SSBhbSBHcm9vdC4=".asSlice(); +let fizz: Slice = s.fromBase64(); +``` + +## Int.toString + +```tact +extends fun toString(self: Int): String; +``` + +Extension function for the [`Int{:tact}`][int]. + +Returns a [`String{:tact}`][p] from an [`Int{:tact}`][int] value. + +Usage example: + +```tact +let fizz: String = (84 - 42).toString(); +``` + +## Int.toFloatString + +```tact +extends fun toFloatString(self: Int, digits: Int): String; +``` + +Extension function for the [`Int{:tact}`][int]. + +Returns a [`String{:tact}`][p] from an [`Int{:tact}`][int] value using a [fixed-point representation](https://en.wikipedia.org/wiki/Fixed-point_arithmetic) of a fractional number, where `self` is a significant part of the number and `digits` is a number of digits in the fractional part. + +More precisely, `digits` is an exponentiation parameter of $10^{-\mathrm{digits}}$ expression, which gives the represented fractional number when multiplied by the actual [`Int{:tact}`][int] value. Parameter `digits` is required to be in the closed interval: $0 <$ `digits` $< 78$, otherwise an exception with [exit code 134](/book/exit-codes#134) will be thrown: `Invalid argument`. + +Usage example: + +```tact +let fizz: String = (42).toFloatString(9); // "0.000000042" +``` + +## Int.toCoinsString + +```tact +extends fun toCoinsString(self: Int): String; +``` + +Extension function for the [`Int{:tact}`][int]. + +Returns a [`String{:tact}`][p] from an [`Int{:tact}`][int] value using a [fixed-point representation](https://en.wikipedia.org/wiki/Fixed-point_arithmetic) of a fractional number. Alias to `self.toFloatString(9){:tact}`. + +This is used to represent [nanoToncoin](/book/integers#nanotoncoin) [`Int{:tact}`][int] values using strings. + +Usage example: + +```tact +let nanotons: Int = 42; +let fizz: String = nanotons.toCoinsString(); +let buzz: String = nanotons.toFloatString(9); + +fizz == buzz; // true, both store "0.000000042" +``` + +## Address.toString + +```tact +extends fun toString(self: Address): String; +``` + +Extension function for the [`Address{:tact}`][p]. + +Returns a [`String{:tact}`][p] from an [`Address{:tact}`][p]. + +Usage example: + +```tact +let community: Address = address("UQDpXLZKrkHsOuE_C1aS69C697wE568vTnqSeRfBXZfvmVOo"); +let fizz: String = community.toString(); +``` + +[p]: /book/types#primitive-types +[bool]: /book/types#booleans +[int]: /book/integers +[cell]: /book/cells#cells +[slice]: /book/cells#slices diff --git a/docs/src/content/docs/ref/evolution/otp-001.mdx b/docs/src/content/docs/ref/evolution/otp-001.mdx new file mode 100644 index 000000000..5330d78f7 --- /dev/null +++ b/docs/src/content/docs/ref/evolution/otp-001.mdx @@ -0,0 +1,56 @@ +--- +title: "OTP-001: Supported Interfaces" +sidebar: + order: 1 +--- + +This proposal recommends a way to introspect smart contracts and find out what interfaces they support. + +## Motivation + +Right now it is impossible to guess what a user wants to do with a contract or can't figure out what the transaction is about because there is no clear way to find what a contract is about. Humans need to remember or guess what this was about in most ways. + +## Guide + +When human tries to sign a transaction, they need to understand clearly what they are doing: minting, token transfer, staking, DAO voting. While Ethereum wallets support signing arbitrary structures it is still not clear what are you signing and what's the implications of doing so. In the same way, explorers can't show what's going on in a nice form. + +The start of a working with specific contract is a performing introspection - figuring out what the contract declares about itself. When the app knows what this contract is about it could build a good UI, show transaction history, and verify what a human tries to sign. + +This proposal describes a way to report what interfaces the contract supports. + +Interfaces are defined in a free-form specification. Unlike most of the other approaches, this proposal defines interface as not only the technical interface of a contract (get methods, internal messages, etc) but also a description of its behavior. Attaching a hash of the representation of a technical interface of a contract could cause conflicts between different standards and because of this proposal defines interfaces loosely. Also, it allows an interface to be more fluid, for example token that couldn't be transferred could be just a contract that will have to get the method `can_transfer` that returns `false` and this would mean that this token doesn't support transfers at all without the need to implement this method. + +Interface IDs are hashes of reverse domain names (like packages in Java), this avoids clashes of names between different teams if they want to build something just for themselves. + +## Specification + +In order to support the introspection contract MUST implement the supports_interface GET method: + +```(int...) supported_interfaces()``` +Which returns a list of supported interface codes. The first value MUST be `hash("org.ton.introspection.v0")` = `123515602279859691144772641439386770278`. +If the first value is incorrect app MUST stop attempting to introspect the contract. +Example +```func +_ supported_interfaces() method_id { + return (123515602279859691144772641439386770278); +} +``` + +The hash of an interface is defined as truncated to 128 bits SHA256. + +## Drawbacks + +This proposal doesn't guarantee that the contract would behave correctly to an interface, also it doesn't provide a guaranteed way to avoid name clashes between different interfaces. This is a non-goal for this proposal. + +This proposal isn't tied to a specific technical interface. This could lead to multiple interfaces that do the same thing but with different IDs. This is a non-goal for this proposal since a centralized registry would be very useful for existing interfaces and a custom one would be used mostly in-house. + +## Rationale and alternatives + +- Why 128 bit? We are looking at a global namespace that we need to keep without conflicts, we can't use anything much smaller since the probability of conflicts would be much higher. We are looking at UUID-like entropy that is exactly 128-bit and is time-proven. More than 128 is too wasteful. +- Why freeform? As mentioned before, it is easier just to define some ID to start work early and then eventually build a standard. Also interfaces (like ERC20) usually not just a technical interface, but also a number of rules on how to work with it. +- Why not find out what contract supports by decompiling? Explicit is always better than implicit in open-world scenarios. We can't rely on our "disassembling" capabilities to perform introspections, even small errors could be fatal. +- Why not hash of representation? Right now there are no compilers that support that, also this proposal is future-proof. If anyone would want to build something more automated they could easily build their own hashes by their own rules keeping everything the same for external observers. + +## Prior art + +[Ethereum Interface Detection](https://eips.ethereum.org/EIPS/eip-165) diff --git a/docs/src/content/docs/ref/evolution/otp-002.mdx b/docs/src/content/docs/ref/evolution/otp-002.mdx new file mode 100644 index 000000000..599063769 --- /dev/null +++ b/docs/src/content/docs/ref/evolution/otp-002.mdx @@ -0,0 +1,78 @@ +--- +title: "OTP-002: Contract ABI" +sidebar: + order: 2 +--- + +ABI defines how to communicate with smart contracts. It contains information about the contract's receivers, data structures, etc. + +## Motivation + +ABI is an essential tool that allows developers to generate handy bindings, UIs, etc. One of the best consumer usages would be using a DAO and being able to confirm what exactly it is trying to do before signing a transaction. + +## Guide + +This OTP is based on types that are defined in TLB+ and it is advised to know them before reading this OTP. + +## Specification + +ABI is a JSON file: + +```json +{ + "name": "MyContract", + "types": [ + { + "name": "MyRequest", + "header": 12315123, + "fields": [ + { + "name": "queryId", + "type": { + "kind": "simple", + "type": "int", + "optional": false, + "format": "uint256" + } + } + ] + } + ], + "receivers": [ + { "type": "binary", "kind": "internal", "name": "MyRequest" }, + { "type": "binary", "kind": "internal" }, + { "type": "comment", "kind": "internal", "comment": "Vote!" }, + { "type": "comment", "kind": "internal" }, + { "type": "empty", "kind": "internal" } + ], + "getters": [ + { "name": "getOwner", "type": "address", "args": [] }, + { + "name": "getBalance", + "type": "coins", + "args": [ + { + "name": "invested", + "type": { + "kind": "simple", + "type": "uint", + "format": "coins" + } + } + ] + } + ], + "errors": { + "123": "Error description", + "124": "Division by zero" + } +} +``` + +## Drawbacks + +- Binary and compact representation of ABI could be better, but it is not critical for now. + +## Prior art + +- OTP-001, that is complimentary to this OTP. diff --git a/docs/src/content/docs/ref/evolution/otp-003.mdx b/docs/src/content/docs/ref/evolution/otp-003.mdx new file mode 100644 index 000000000..b8781cb92 --- /dev/null +++ b/docs/src/content/docs/ref/evolution/otp-003.mdx @@ -0,0 +1,19 @@ +--- +title: "OTP-003: Self-ABI reporting" +sidebar: + order: 3 +--- + +This proposal defines how to report the contract's ABI using the IPFS link. + +## Motivation + +Usually, ABI is supplied separately using a third-party service or via some repository on GitHub. This proposal suggests adding a new self-reporting of the contract's ABI using a link to an IPFS. This would allow us to avoid any third-party dependency and allow anyone to build tools that rely on ABI such as explorers, wallets, etc. + +## Specification + +To support this proposal, the contract should implement OTP-001 and report an interface `org.ton.abi.ipfs.v0`. Then implement a get method `get_abi_ipfs` that returns a string with an IPFS link to the ABI file. The link should be in the format `ipfs://`. + +## Drawbacks + +- No way to upgrade ABI without updating a contract. This is a drawback exists only for hardcoded links. diff --git a/docs/src/content/docs/ref/evolution/otp-004.mdx b/docs/src/content/docs/ref/evolution/otp-004.mdx new file mode 100644 index 000000000..527aed5b5 --- /dev/null +++ b/docs/src/content/docs/ref/evolution/otp-004.mdx @@ -0,0 +1,36 @@ +--- +title: "OTP-004: Auto Encoder" +sidebar: + order: 4 +--- + +This proposal defines a way to automatically build a serialization layout for a given structure. + +## Motivation + +Designing a serialization layout in TLB is a very risky task. Developers have to take care of the size limitations of cells and remember how many bits are used by each field. This is a very error-prone task and it is very easy to make a mistake. This proposal aims to solve this problem by providing a way to automatically build a serialization layout for a given structure. + +## Specification + +We define auto-encoder as an eager algorithm that builds a serialization layout for a given structure. The algorithm is defined as follows: + +```text +Define available references and bits in a current cell + as `available_references` and `available_bits` respectively. + NOTE: there must be at least one reference reserved for the serialization tail and one + bit for an optional flag. Depending on context more references or bits may be reserved. + +For each field in A: + (size_bits, size_ref) = get_field_max_size(field); + if (available_bits >= size_bits && available_references >= size_ref) { + Push field to a current cell + } else { + available_references = (1023 - 1); + available_bits = (4 - 1); + Allocate a new tail and continue from the current field + } +``` + +## Drawbacks + +- This is an implicit algorithm. It is not clear results of this allocator have to be checked to make compatible serialization. diff --git a/docs/src/content/docs/ref/evolution/otp-005.mdx b/docs/src/content/docs/ref/evolution/otp-005.mdx new file mode 100644 index 000000000..9334cdc0e --- /dev/null +++ b/docs/src/content/docs/ref/evolution/otp-005.mdx @@ -0,0 +1,35 @@ +--- +title: "OTP-005: Argument-addressable contracts" +sidebar: + order: 5 +--- + +This proposal defines a way to address contracts by their arguments instead of their initial data. + +## Motivation + +Init data could be very different from the arguments. This allows us to avoid executing untrusted code from another contract in the context of a current one or executing TVM code off-chain for deployment that could be risky in some cases. + +## Specification + +This specification defines a way to write arguments to an init data cell to be read by the contract code during deployment. + +### Prefix + +The prefix is defined by a smart contract itself, but by default, it is assumed as a `single zero bit`. Prefix is used by the contract code to distinguish between deployed and not-deployed state. + +### Arguments encoding + +Arguments are encoded using [Auto Encoder](/ref/evolution/otp-004). + +### Contract Requirements + +- Contract MUST expose `lazy_deployment_completed` get method that returns `true` if the contract is deployed and `false` otherwise. +- Contract MUST expose `org.ton.deploy.lazy.v0` interface. + +## Drawbacks + +- Contracts could be in a semi-deployed state +- There are multiple ways to write arguments that would end up in a different init data and a different address +- You can deploy a pre-initialized contract and it would have a different address while being fully functional +- Unpredictable gas usage on deployment. Deployments are usually expensive, but this proposal makes it even more expensive. diff --git a/docs/src/content/docs/ref/evolution/otp-006.mdx b/docs/src/content/docs/ref/evolution/otp-006.mdx new file mode 100644 index 000000000..993b1ec86 --- /dev/null +++ b/docs/src/content/docs/ref/evolution/otp-006.mdx @@ -0,0 +1,54 @@ +--- +title: "OTP-006: Contract Package" +sidebar: + order: 6 +--- + +This proposal defines a way to package compile contracts, their dependencies, and all related metadata into a single file. + +## Motivation + +A unified package format is needed to simplify the process of deploying and upgrading contracts using various tools without the need to configure them. + +## Specification + +The package file has an extension `.pkg` and is a JSON file: + +```json +{ + "name": "My Contract", + "code": "... boc of code ...", + "abi": "ABI string to be uploaded as is to IPFS or Ton Storage", + "init": { + "kind": "direct", // Means that this contract can be deployed as is + "args": { + // ... Arguments in ABI format + }, + "prefix": { + // Optional prefix for contract init state + "bits": 0, // Number of bits in prefix + "value": 0 // Value of prefix + }, + "deployment": { + "kind": "system-cell", // Means that this contract can be deployed as is + "system": "... boc of system cell ..." + } + }, + "sources": { + "file.ton": "... base64 encoded source file ..." + }, + "compiler": { + "name": "func", + "version": "0.4.1", + "parameters": "..." // Optional string parameters + } +} +``` + +## Drawbacks + +None + +## Reference + +- Bags of Cells (BoC): https://docs.ton.org/develop/data-formats/cell-boc#packing-a-bag-of-cells diff --git a/docs/src/content/docs/ref/evolution/overview.mdx b/docs/src/content/docs/ref/evolution/overview.mdx new file mode 100644 index 000000000..d1937341f --- /dev/null +++ b/docs/src/content/docs/ref/evolution/overview.mdx @@ -0,0 +1,50 @@ +--- +title: Evolution overview +sidebar: + label: Overview + order: 0 +--- + +import { LinkCard, CardGrid } from '@astrojs/starlight/components'; + +This sub-section contains all standards that are defined by the Tact Foundation and are used in the evolution process of the Tact and TON ecosystem. +Additionally, it features TEPs (TON Enhancement Proposals) and the up-to-date changelog of Tact updates. + +## Open Tact Proposals (OTPs) + + + + + + + + + + +## TON Enhancement Protocols (TEPs) + +The main goal of TON Enhancement Proposals is to provide a convenient and formal way to propose changes to TON Blockchain and standardize ways of interaction between different parts of ecosystem. Proposal management is done using GitHub pull requests, the process is described formally in [TEP-1](https://github.com/ton-blockchain/TEPs/blob/master/text/0001-tep-lifecycle.md). + +List of [merged TEPs](https://github.com/ton-blockchain/TEPs#merged-teps). + +## Changelog + +All notable changes to the main Tact repository are documented in the [CHANGELOG.md](https://github.com/tact-lang/tact/blob/main/CHANGELOG.md). diff --git a/docs/src/content/docs/ref/index.mdx b/docs/src/content/docs/ref/index.mdx new file mode 100644 index 000000000..aa53c431d --- /dev/null +++ b/docs/src/content/docs/ref/index.mdx @@ -0,0 +1,57 @@ +--- +title: Reference overview +--- + +import { LinkCard, CardGrid, Steps } from '@astrojs/starlight/components'; + +Welcome to the **Reference** section of Tact documentation — a place for discovering the Tact's standard library, grammar specification and evolution process. + +Here are its main contents: + + + +1. #### Core library + + [Core library](/ref/core-base) gives a comprehensive list of auto-included functions, traits and other constructs with examples of their usage. + + + + + +2. #### Standard libraries + + [Standard libraries](/ref/standard-libraries) sub-section explains how to use the bundled libraries, lists all their contents with examples of their usage. + + + + + +3. #### Specification + + [Specification](/ref/spec) page provides full Tact grammar written in Ohm language, which is used in the Tact's compiler. Aimed at more experienced programmers, but generally can still be very handy to quickly grasp all of the possible syntax in the language. + + + + + +4. #### Evolution + + Finally, [Evolution](/ref/evolution/overview) sub-section gives insight on important decisions about language semantics, Tact's future and links to the up-to-date changelog of Tact updates. + + + + + + diff --git a/docs/src/content/docs/ref/spec.mdx b/docs/src/content/docs/ref/spec.mdx new file mode 100644 index 000000000..3b8c57c08 --- /dev/null +++ b/docs/src/content/docs/ref/spec.mdx @@ -0,0 +1,306 @@ +--- +title: Tact Specification +pagefind: false # hide the page from the search index +--- + +:::danger[Not implemented] + This page is mostly a stub until it's implemented in [#76](https://github.com/tact-lang/tact-docs/issues/76) +::: + +Tact grammar used in its compiler is written in an [Ohm language](https://ohmjs.org), which is based on [parsing expression grammars](http://en.wikipedia.org/wiki/Parsing_expression_grammar) (PEGs), which are a formal way of describing syntax, similar to regular expressions and context-free grammars. + +{/* + This is a comment and it's hidden from the page. + + Shiki does a bad job of highlighting Ohm via TextMate grammar, although it works well in VSCode. I think the reason may be either due to Shiki highlighting line by line or that it uses a different RegEx engine. I'm not sure what's the issue there, so until it's fixed it's better to use tree-sitter-ohm and generate ANSI sequences using its `highlight` command. Then Shiki does the rest: +*/} + +```ansi +Tact { + + // Starting point of the program + Program = ProgramItem* + ProgramItem = Struct + | Contract + | Primitive + | StaticFunction + | NativeFunction + | ProgramImport + | Trait + | Constant + ProgramImport = import stringLiteral ";" + + // Built-in declarations + Primitive = "primitive" Type ";" + + // Static function + StaticFunction = Function + NativeFunction = nameAttribute "(" funcId ")" FunctionAttribute* native id "(" ListOf<FunctionArg,","> ")" ";" --withVoid + | nameAttribute "(" funcId ")" FunctionAttribute* native id "(" ListOf<FunctionArg,","> ")" ":" Type ";" --withType + + // Field declarations + Type = typeLiteral "?" --optional + | typeLiteral --required + | "map" "<" typeLiteral (as id)? "," typeLiteral (as id)? ">" --map + | "bounced" "<" typeLiteral ">" --bounced + Field = id ":" Type ";" --default + | id ":" Type "=" Expression ";" --defaultWithInit + | id ":" Type as id ";" --withSerialization + | id ":" Type as id "=" Expression ";" --withSerializationAndInit + + // Constant + ConstantAttribute = virtual --virtual + | override --override + | abstract --abstract + Constant = ConstantAttribute* ~fun const id ":" Type "=" Expression ";" --withValue + | ConstantAttribute* ~fun const id ":" Type ";" --withEmpty + + // Struct + Struct = "struct" typeLiteral "{" StructBody* "}" --originary + | "message" typeLiteral "{" StructBody* "}" --message + | "message" "(" integerLiteral ")" typeLiteral "{" StructBody* "}" --messageWithId + StructBody = Field + + // Contract + Contract = ContractAttribute* contract id "{" ContractBody* "}" --simple + | ContractAttribute* contract id with ListOf<id,","> "{" ContractBody* "}" --withTraits + ContractInit = "init" "(" ListOf<FunctionArg,","> ")" "{" Statement* "}" + ContractBody = Field + | ContractInit + | ReceiveFunction + | Function + | Constant + + // Trait + Trait = ContractAttribute* trait id "{" TraitBody* "}" --originary + | ContractAttribute* trait id with ListOf<id,","> "{" TraitBody* "}" --withTraits + TraitBody = Field + | ReceiveFunction + | Function + | Constant + + // Contract attributes + ContractAttribute = "@interface" "(" stringLiteral ")" --interface + + // Function + FunctionAttribute = "get" --getter + | mutates --mutates + | extends --extends + | virtual --virtual + | override --override + | inline --inline + | abstract --abstract + Function = FunctionAttribute* fun id "(" ListOf<FunctionArg,","> ")" "{" Statement* "}" --withVoid + | FunctionAttribute* fun id "(" ListOf<FunctionArg,","> ")" ":" Type "{" Statement* "}" --withType + | FunctionAttribute* fun id "(" ListOf<FunctionArg,","> ")" ";" --abstractVoid + | FunctionAttribute* fun id "(" ListOf<FunctionArg,","> ")" ":" Type ";" --abstractType + FunctionArg = id ":" Type + + ReceiveFunction = "receive" "(" FunctionArg ")" "{" Statement* "}" --simple + | "receive" "(" ")" "{" Statement* "}" --empty + | "receive" "(" stringLiteral ")" "{" Statement* "}" --comment + | "bounced" "(" FunctionArg ")" "{" Statement* "}" --bounced + | "external" "(" FunctionArg ")" "{" Statement* "}" --externalSimple + | "external" "(" stringLiteral ")" "{" Statement* "}" --externalComment + | "external" "(" ")" "{" Statement* "}" --externalEmpty + + // Statements + Statement = StatementLet + | StatementBlock + | StatementReturn + | StatementExpression + | StatementAssign + | StatementAugmentedAssign + | StatementCondition + | StatementWhile + | StatementRepeat + | StatementUntil + StatementBlock = "{" Statement* "}" + StatementLet = let id ":" Type "=" Expression ";" + StatementReturn = return Expression ";" --withExpression + | return ";" --withoutExpression  + StatementExpression = Expression ";" + StatementAssign = LValue "=" Expression ";" + StatementAugmentedAssign = StatementAugmentedAssignAdd + | StatementAugmentedAssignSub + | StatementAugmentedAssignMul + | StatementAugmentedAssignDiv + | StatementAugmentedAssignRem + StatementAugmentedAssignAdd = LValue "+=" Expression ";" + StatementAugmentedAssignSub = LValue "-=" Expression ";" + StatementAugmentedAssignMul = LValue "*=" Expression ";" + StatementAugmentedAssignDiv = LValue "/=" Expression ";" + StatementAugmentedAssignRem = LValue "%=" Expression ";" + StatementCondition = if Expression "{" Statement* "}" ~else --simple + | if Expression "{" Statement* "}" else "{" Statement* "}" --withElse + | if Expression "{" Statement* "}" else StatementCondition --withElseIf + StatementWhile = while "(" Expression ")" "{" Statement* "}" + StatementRepeat = repeat "(" Expression ")" "{" Statement* "}" + StatementUntil = do "{" Statement* "}" until "(" Expression ")" ";" + + // L-value + LValue = id "." LValue --more + | id --single + + // Expressions + Expression = ExpressionConditional + ExpressionConditional = ExpressionOr "?" ExpressionOr ":" ExpressionConditional --ternary + | ExpressionOr + ExpressionOr = ExpressionOr "||" ExpressionAnd --or + | ExpressionAnd + ExpressionAnd = ExpressionAnd "&&" ExpressionCompare --and + | ExpressionCompare + ExpressionCompare = ExpressionCompare "!=" ExpressionBinary --not + | ExpressionCompare "==" ExpressionBinary --eq + | ExpressionCompare ">" ExpressionBinary --gt + | ExpressionCompare ">=" ExpressionBinary --gte + | ExpressionCompare "<" ExpressionBinary --lt + | ExpressionCompare "<=" ExpressionBinary --lte + | ExpressionBinary + ExpressionBinary = ExpressionBinary ">>" ExpressionAdd --shr + | ExpressionBinary "<<" ExpressionAdd --shl + | ExpressionBinary "&" ExpressionAdd --bin_and + | ExpressionBinary "|" ExpressionAdd --bin_or + | ExpressionAdd + ExpressionAdd = ExpressionAdd "+" ~"+" ExpressionMul --add + | ExpressionAdd "-" ~"-" ExpressionMul --sub + | ExpressionMul + ExpressionMul = ExpressionMul "*" ExpressionUnary --mul + | ExpressionMul "/" ExpressionUnary --div + | ExpressionMul "%" ExpressionUnary --rem + | ExpressionUnary + ExpressionUnary = "-" ExpressionUnarySuffix --neg + | "+" ExpressionUnarySuffix --add + | "!" ExpressionUnarySuffix --not + | ExpressionUnarySuffix + ExpressionUnarySuffix = ExpressionValue "!!" --notNull + | ExpressionValue + ExpressionBracket = "(" Expression ")" + + // Order is important + ExpressionValue = ExpressionCall + | ExpressionField + | ExpressionStaticCall + | ExpressionBracket + | ExpressionNew + | integerLiteral + | boolLiteral + | id + | null + | ExpressionInitOf + | ExpressionString + ExpressionString = stringLiteral + ExpressionField = ExpressionValue "." id ~"(" + ExpressionCall = ExpressionValue "." id "(" ListOf<Expression, ","> ")" + ExpressionNew = id "{" ListOf<NewParameter, ","> "}" + NewParameter = id ":" Expression + ExpressionStaticCall = id "(" ListOf<Expression, ","> ")" + ExpressionInitOf = initOf id "(" ListOf<Expression, ","> ")" + + // Type Literal + typeLiteral = letterAsciiUC typeLiteralPart* + typeLiteralPart = letterAscii | digit | "_" + + // Integer Literal + // hexDigit defined in Ohm's built-in rules (otherwise: hexDigit = "0".."9" | "a".."f" | "A".."F") + // digit defined in Ohm's built-in rules (otherwise: digit = "0".."9") + integerLiteral = integerLiteralHex | integerLiteralBin | integerLiteralOct | integerLiteralDec // Order is important + integerLiteralDec = nonZeroDigit ("_"? digit)* --nonZeroIntegerLiteralDec + | "0" digit* --integerLiteralWithLeadingZero + integerLiteralHex = ("0x" | "0X") hexDigit ("_"? hexDigit)* + integerLiteralBin = ("0b" | "0B") binDigit ("_"? binDigit)* + integerLiteralOct = ("0o" | "0O") octDigit ("_"? octDigit)* + binDigit = "0" | "1" + octDigit = "0".."7" + nonZeroDigit = "1".."9" + + // Letters + letterAsciiLC = "a".."z" + letterAsciiUC = "A".."Z" + letterAscii = letterAsciiLC | letterAsciiUC + letterComment = letterAsciiLC | letterAsciiUC | digit | "_" + + // ID Literal + idStart = letterAscii | "_" + idPart = letterAscii | digit | "_" + id = ~reservedWord #idStart #(idPart*) + + // FunC id + funcLetter = letterAscii | "_" | "'" | "?" | "!" | "::" | "&" + funcId = funcLetter #(funcLetter | digit)* + + // Bool Literal + boolLiteral = ("true" | "false") ~idPart + + // String literal + stringLiteralCharacter = ~("\"" | "\\" | lineTerminator) any + stringLiteral = "\"" stringLiteralCharacter* "\"" + + // Keywords + // NOTE Order is important + keyword = fun + | let + | return + | extend + | native + | public + | null + | if + | else + | while + | repeat + | do + | until + | as + | mutates + | extends + | import + | with + | trait + | initOf + | override + | abstract + | virtual + | inline + | const + contract = "contract" ~idPart + let = "let" ~idPart + fun = "fun" ~idPart + return = "return" ~idPart + extend = "extend" ~idPart + native = "native" ~idPart + public = "public" ~idPart + null = "null" ~idPart + if = "if" ~idPart + else = "else" ~idPart + while = "while" ~idPart + repeat = "repeat" ~idPart + do = "do" ~idPart + until = "until" ~idPart + as = "as" ~idPart + mutates = "mutates" ~idPart + extends = "extends" ~idPart + import = "import" ~idPart + with = "with" ~idPart + trait = "trait" ~idPart + initOf = "initOf" ~idPart + virtual = "virtual" ~idPart + override = "override" ~idPart + inline = "inline" ~idPart + const = "const" ~idPart + abstract = "abstract" ~idPart + + // Attributes + nameAttribute = "@name" + + // Reserved + reservedWord = keyword + + // Comments + space += comment | lineTerminator + comment = multiLineComment | singleLineComment + lineTerminator = "\n" | "\r" | "\u2028" | "\u2029" + multiLineComment = "/*" (~"*/" any)* "*/" + singleLineComment = "//" (~lineTerminator any)* +} +``` diff --git a/docs/src/content/docs/ref/standard-libraries.mdx b/docs/src/content/docs/ref/standard-libraries.mdx new file mode 100644 index 000000000..3000c0a05 --- /dev/null +++ b/docs/src/content/docs/ref/standard-libraries.mdx @@ -0,0 +1,50 @@ +--- +title: Standard libraries overview +--- + +Some libraries (also referred to as standard libraries or stdlibs) come bundled with Tact compiler, but aren't automatically included to your project until explicitly made to. + +To import any standard library, use the [`import{:tact}` keyword](/book/import) followed by the name of that library in a [string][p], like so: + +```tact +// This would include everything from @stdlib/deploy into your codebase: +import "@stdlib/deploy"; +``` + +## List of standard libraries: {#list} + +Library | Description | Commonly used APIs +:----------------------- | :--------------------------------------------------------------- | :----------------- +[`@stdlib/config`][1] | Config and elector address retrieval. | [`getConfigAddress(){:tact}`][gca], [`getElectorAddress(){:tact}`][gea] +[`@stdlib/content`][2] | Encoding off-chain link [strings][p] to a [`Cell{:tact}`][cell]. | [`createOffchainContent(){:tact}`][coff] +[`@stdlib/deploy`][3] | Unified mechanism for deployments. | [`Deployable{:tact}`][dep], [`FactoryDeployable{:tact}`][fcd] +[`@stdlib/dns`][4] | Resolution of [DNS][dns] names. | [`DNSResolver{:tact}`][dnsr], [`dnsInternalVerify(){:tact}`][dnsi] +[`@stdlib/ownable`][5] | Traits for ownership management. | [`Ownable{:tact}`][own], [`OwnableTransferable{:tact}`][ownt] +[`@stdlib/stoppable`][6] | Traits that allow contract stops. Requires [@stdlib/ownable][5]. | [`Stoppable{:tact}`][stp], [`Resumable{:tact}`][res] + +[1]: /ref/stdlib-config +[gca]: /ref/stdlib-config#getconfigaddress +[gea]: /ref/stdlib-config#getelectoraddress + +[2]: /ref/stdlib-content +[coff]: /ref/stdlib-content#createoffchaincontent + +[3]: /ref/stdlib-deploy +[dep]: /ref/stdlib-deploy#deployable +[fcd]: /ref/stdlib-deploy#factorydeployable + +[4]: /ref/stdlib-dns +[dnsr]: /ref/stdlib-dns#dnsresolver +[dnsi]: /ref/stdlib-dns#dnsinternalverify + +[5]: /ref/stdlib-ownable +[own]: /ref/stdlib-ownable#ownable +[ownt]: /ref/stdlib-ownable#ownabletransferable + +[6]: /ref/stdlib-stoppable +[stp]: /ref/stdlib-stoppable#stoppable +[res]: /ref/stdlib-stoppable#resumable + +[p]: /book/types#primitive-types +[cell]: /book/cells#cells +[dns]: https://docs.ton.org/participate/web3/dns diff --git a/docs/src/content/docs/ref/stdlib-config.mdx b/docs/src/content/docs/ref/stdlib-config.mdx new file mode 100644 index 000000000..5443f0855 --- /dev/null +++ b/docs/src/content/docs/ref/stdlib-config.mdx @@ -0,0 +1,55 @@ +--- +title: "@stdlib/config" +--- + +Provides functions for config and elector Address retrieval. + +To use this library, import `@stdlib/config`: + +```tact +import "@stdlib/config"; +``` + +## Functions + +### getConfigAddress + +```tact +fun getConfigAddress(): Address; +``` + +Retrieves config parameter $0$ as an [`Address{:tact}`][p]. + +Source code: + +```tact +fun getConfigAddress(): Address { + let cell: Cell = getConfigParam(0)!!; + let sc: Slice = cell.beginParse(); + return newAddress(-1, sc.loadUint(256)); +} +``` + +### getElectorAddress + +```tact +fun getElectorAddress(): Address; +``` + +Retrieves config parameter $1$ as an [`Address{:tact}`][p]. + +Source code: + +```tact +fun getElectorAddress(): Address { + let cell: Cell = getConfigParam(1)!!; + let sc: Slice = cell.beginParse(); + return newAddress(-1, sc.loadUint(256)); +} +``` + +## Sources + +* [config.tact](https://github.com/tact-lang/tact/blob/61541b7783098e1af669faccd7d2334c10981c72/stdlib/libs/config.tact) + +[p]: /book/types#primitive-types diff --git a/docs/src/content/docs/ref/stdlib-content.mdx b/docs/src/content/docs/ref/stdlib-content.mdx new file mode 100644 index 000000000..4acf52b79 --- /dev/null +++ b/docs/src/content/docs/ref/stdlib-content.mdx @@ -0,0 +1,38 @@ +--- +title: "@stdlib/content" +--- + +Provides a function for encoding an off-chain link from a [`String{:tact}`][p] to a [`Cell{:tact}`][cell]. + +To use this library, import `@stdlib/content`: + +```tact +import "@stdlib/content"; +``` + +## Functions + +### createOffchainContent + +```tact +fun createOffchainContent(link: String): Cell; +``` + +Encodes an off-chain `link` from a [`String{:tact}`][p] to a [`Cell{:tact}`][cell]. + +Source code: + +```tact +fun createOffchainContent(link: String): Cell { + let builder: StringBuilder = beginStringFromBuilder(beginCell().storeUint(0x01, 8)); + builder.append(link); + return builder.toCell(); +} +``` + +## Sources + +* [content.tact](https://github.com/tact-lang/tact/blob/61541b7783098e1af669faccd7d2334c10981c72/stdlib/libs/content.tact) + +[p]: /book/types#primitive-types +[cell]: /book/cells#cells diff --git a/docs/src/content/docs/ref/stdlib-deploy.mdx b/docs/src/content/docs/ref/stdlib-deploy.mdx new file mode 100644 index 000000000..2af456b2a --- /dev/null +++ b/docs/src/content/docs/ref/stdlib-deploy.mdx @@ -0,0 +1,96 @@ +--- +title: "@stdlib/deploy" +--- + +Provides unified mechanisms for deployments. + +To use this library, import `@stdlib/deploy`: + +```tact +import "@stdlib/deploy"; +``` + +## Messages + +### Deploy + +```tact +message Deploy { + queryId: Int as uint64; +} +``` + +### DeployOk + +```tact +message DeployOk { + queryId: Int as uint64; +} +``` + +### FactoryDeploy + +```tact +message FactoryDeploy { + queryId: Int as uint64; + cashback: Address; +} +``` + +## Traits + +### Deployable + +Simplest trait `Deployable{:tact}` that provides a handy unified mechanism for deployments by implementing a simple receiver for the [Deploy](#deploy) message. + +All contracts are deployed by sending them a message. While any message can be used for this purpose, best practice is to use the special [Deploy](#deploy) message. + +This message has a single field, `queryId`, provided by the deployer (usually set to zero). If the deployment succeeds, the contract will reply with a [DeployOk](#deployok) message and echo the same `queryId` in the response. + +Source code: + +```tact +trait Deployable { + receive(deploy: Deploy) { + self.notify(DeployOk{queryId: deploy.queryId}.toCell()); + } +} +``` + +Usage example: + +```tact /Deployable/ +import "@stdlib/deploy"; + +contract ExampleContract with Deployable { + // Now, this contract has a receiver for Deploy message +} +``` + +### FactoryDeployable + +Trait `FactoryDeployable{:tact}` provides a handy unified mechanism for chained deployments. + +Source code: + +```tact +trait FactoryDeployable { + receive(deploy: FactoryDeploy) { + self.forward(deploy.cashback, DeployOk{queryId: deploy.queryId}.toCell(), false, null); + } +} +``` + +Usage example: + +```tact /FactoryDeployable/ +import "@stdlib/deploy"; + +contract ExampleContract with FactoryDeployable { + // Now, this contract has a receiver for FactoryDeploy message +} +``` + +## Sources + +* [deploy.tact](https://github.com/tact-lang/tact/blob/61541b7783098e1af669faccd7d2334c10981c72/stdlib/libs/deploy.tact) diff --git a/docs/src/content/docs/ref/stdlib-dns.mdx b/docs/src/content/docs/ref/stdlib-dns.mdx new file mode 100644 index 000000000..2dcf372e3 --- /dev/null +++ b/docs/src/content/docs/ref/stdlib-dns.mdx @@ -0,0 +1,194 @@ +--- +title: "@stdlib/dns" +--- + +Provides means for resolution of [DNS](https://docs.ton.org/participate/web3/dns) names. + +To use this library, import `@stdlib/dns`: + +```tact +import "@stdlib/dns"; +``` + +## Structs + +### DNSResolveResult + +```tact +struct DNSResolveResult { + prefix: Int; + record: Cell?; +} +``` + +## Functions + +### dnsStringToInternal + +```tact +@name(dns_string_to_internal) +native dnsStringToInternal(str: String): Slice?; +``` + +Converts a DNS string to a [`Slice{:tact}`][slice] or [`null{:tact}`](/book/optionals), if it's impossible. + +Source code (FunC): [dns.fc#L1](https://github.com/tact-lang/tact/blob/e69c7fc99dc9be3fa5ff984456c03ffe8fed3677/stdlib/libs/dns.fc#L1) + +### dnsInternalNormalize + +```tact +@name(dns_internal_normalize) +native dnsInternalNormalize(src: Slice): Slice; +``` + +Normalizes the internal DNS representation of the [`Slice{:tact}`][slice]. The passed [`Slice{:tact}`][slice] must not have any references, otherwise an exception wit [exit code 134](/book/exit-codes#134) will be thrown: `Invalid argument`. + +Source code (FunC): [dns.fc#L125](https://github.com/tact-lang/tact/blob/e69c7fc99dc9be3fa5ff984456c03ffe8fed3677/stdlib/libs/dns.fc#L125) + +### dnsInternalVerify + +```tact +@name(dns_internal_verify) +native dnsInternalVerify(subdomain: Slice): Bool; +``` + +Verifies the internal DNS representation of the subdomain [`Slice{:tact}`][slice]. + +Source code (FunC): [dns.fc#L81](https://github.com/tact-lang/tact/blob/e69c7fc99dc9be3fa5ff984456c03ffe8fed3677/stdlib/libs/dns.fc#L81) + +### dnsExtractTopDomainLength + +```tact +fun dnsExtractTopDomainLength(subdomain: Slice): Int; +``` + +Calculates length of a top domain in the `subdomain` [`Slice{:tact}`][slice]. + +Source code: + +```tact +fun dnsExtractTopDomainLength(subdomain: Slice): Int { + let i: Int = 0; + let needBreak: Bool = false; + do { + let char: Int = subdomain.loadUint(8); // we do not check domain.length because it MUST contain \0 character + needBreak = char == 0; + if (!needBreak) { + i += 8; + } + } until (needBreak); + require(i != 0, "Invalid DNS name"); + return i; +} +``` + +### dnsExtractTopDomain + +```tact +fun dnsExtractTopDomain(subdomain: Slice): Slice; +``` + +Extracts top domain from a `subdomain` [`Slice{:tact}`][slice]. + +Source code: + +```tact +fun dnsExtractTopDomain(subdomain: Slice): Slice { + let len: Int = dnsExtractTopDomainLength(subdomain); + return subdomain.loadBits(len); +} +``` + +### dnsResolveNext + +```tact +fun dnsResolveNext(address: Address): Cell; +``` + +Resolves an `address` [`Address{:tact}`][p] into a [`Cell{:tact}`][cell]. + +Source code: + +```tact +fun dnsResolveNext(address: Address): Cell { + return beginCell() + .storeUint(0xba93, 16) + .storeAddress(address) + .endCell(); +} +``` + +### dnsResolveWallet + +```tact +fun dnsResolveWallet(address: Address): Cell; +``` + +Resolves a wallet `address` [`Address{:tact}`][p] into a [`Cell{:tact}`][cell]. + +Source code: + +```tact +fun dnsResolveWallet(address: Address): Cell { + return beginCell() + .storeUint(0x9fd3, 16) + .storeAddress(address) + .storeUint(0, 8) + .endCell(); +} +``` + +## Traits + +### DNSResolver + +Trait `DNSResolver` provides two helper functions for DNS resolution: + +1. [getter function](/book/functions#getter-functions) `dnsresolve(){:tact}`, which corresponds to its [FunC variant](https://docs.ton.org/develop/howto/subresolvers#dnsresolve-code). +2. virtual function `doResolveDNS(){:tact}`, which creates a struct [DNSResolveResult](#dnsresolveresult) out of subdomain [`Slice{:tact}`][slice] bits. + +Source code: + +```tact +trait DNSResolver { + get fun dnsresolve(subdomain: Slice, category: Int): DNSResolveResult { + // Normalize + let delta: Int = 0; + if (subdomain.preloadUint(8) == 0) { + subdomain.loadUint(8); // Skip first byte + delta += 8; + } + + // Checks correctness + require(dnsInternalVerify(subdomain), "Invalid DNS name"); + + // Resolve + let res: DNSResolveResult = self.doResolveDNS(subdomain, category); + return DNSResolveResult{prefix: res.prefix + delta, record: res.record}; + } + virtual fun doResolveDNS(subdomain: Slice, category: Int): DNSResolveResult { + return DNSResolveResult{prefix: subdomain.bits(), record: null}; + } +} +``` + +Usage example: + +```tact +import "@stdlib/dns"; + +contract ExampleContract with DNSResolver { + // Now, this contract has a: + // 1. dnsresolve getter function + // 2. doResolveDNS virtual function +} +``` + +## Sources + +* [dns.tact](https://github.com/tact-lang/tact/blob/61541b7783098e1af669faccd7d2334c10981c72/stdlib/libs/dns.tact) +* [dns.fc](https://github.com/tact-lang/tact/blob/e69c7fc99dc9be3fa5ff984456c03ffe8fed3677/stdlib/libs/dns.fc) + +[p]: /book/types#primitive-types +[cell]: /book/cells#cells +[slice]: /book/cells#slices diff --git a/docs/src/content/docs/ref/stdlib-ownable.mdx b/docs/src/content/docs/ref/stdlib-ownable.mdx new file mode 100644 index 000000000..ef75516c6 --- /dev/null +++ b/docs/src/content/docs/ref/stdlib-ownable.mdx @@ -0,0 +1,114 @@ +--- +title: "@stdlib/ownable" +--- + +Provides [traits](/book/types#composite-types) for ownable contracts. This is most commonly used trait that is required by most other traits. + +To use this library, import `@stdlib/ownable`: + +```tact +import "@stdlib/ownable"; +``` + +## Messages + +### ChangeOwner + +```tact +message ChangeOwner { + queryId: Int as uint64; + newOwner: Address; +} +``` + +### ChangeOwnerOk + +```tact +message ChangeOwnerOk { + queryId: Int as uint64; + newOwner: Address; +} +``` + +## Traits + +### Ownable + +[Trait](/book/types#composite-types) `Ownable{:tact}` declares an owner (non-editable) of a [contract](/book/contracts) and provides a helper function `requireOwner(){:tact}` that checks that a message was sent by an owner. + +This [trait](/book/types#composite-types) requires a field `owner: Address{:tact}` to be declared and exposes a [getter function](/book/functions#getter-functions) `owner(){:tact}`, which reads it from the [contract](/book/contracts). + +Source code: + +```tact +@interface("org.ton.ownable") +trait Ownable { + owner: Address; + + fun requireOwner() { + nativeThrowUnless(132, sender() == self.owner); + } + + get fun owner(): Address { + return self.owner; + } +} +``` + +Usage example: + +```tact /Ownable/ +import "@stdlib/ownable"; + +contract ExampleContract with Ownable { + owner: Address; + + init(owner: Address) { + self.owner = owner; + } +} +``` + +### OwnableTransferable + +`OwnableTransferable{:tact}` is an extension of an [`Ownable{:tact}`](#ownable) that allows to transfer ownership of a contract to another address. It provides a secure handle [Message](/book/structs-and-messages#messages) [`ChangeOwner{:tact}`](#changeowner) that could be called by an owner to transfer ownership. + +If the owner transfer request succeeds, the contract will reply with a [`ChangeOwnerOk{:tact}`](#changeownerok) [Message](/book/structs-and-messages#messages). + +Source code: + +```tact +@interface("org.ton.ownable.transferable.v2") +trait OwnableTransferable with Ownable { + owner: Address; + + receive(msg: ChangeOwner) { + // Check if the sender is the owner + self.requireOwner(); + + // Update owner + self.owner = msg.newOwner; + + // Reply result + self.reply(ChangeOwnerOk{ queryId: msg.queryId, newOwner: msg.newOwner }.toCell()); + } +} +``` + +Usage example: + +```tact /OwnableTransferable/ +import "@stdlib/ownable"; + +contract ExampleContract with OwnableTransferable { + owner: Address; + + init(owner: Address) { + self.owner = owner; + } +} +``` + +## Sources + +* [ownable.tact](https://github.com/tact-lang/tact/blob/61541b7783098e1af669faccd7d2334c10981c72/stdlib/libs/ownable.tact) diff --git a/docs/src/content/docs/ref/stdlib-stoppable.mdx b/docs/src/content/docs/ref/stdlib-stoppable.mdx new file mode 100644 index 000000000..13d5b00c3 --- /dev/null +++ b/docs/src/content/docs/ref/stdlib-stoppable.mdx @@ -0,0 +1,105 @@ +--- +title: "@stdlib/stoppable" +--- + +Provides [traits](/book/types#composite-types) that allow to stop a [contract](/book/contracts). Useful for emergency or maintenance modes. Requires an [`Ownable{:tact}`](/ref/stdlib-ownable#ownable) trait from [`@stdlib/ownable`](/ref/stdlib-ownable). This trait just manages a single flag `stopped` in the contract and handling stopped state have to be done in the contract itself. + +To use this library, import `@stdlib/stoppable`: + +```tact +import "@stdlib/stoppable"; // this would automatically import @stdlib/ownable too! +``` + +## Traits + +### Stoppable + +[Trait](/book/types#composite-types) `Stoppable{:tact}` implements receiver for the [Message](/book/structs-and-messages#messages) [string](/book/types#primitive-types) "Stop" that can be sent by owner, implements `stopped(){:tact}` [getter function](/book/functions#getter-functions) that returns `true{:tact}` if contract is stopped (or `false{:tact}` otherwise) and provides private (non-getter) functions `requireNotStopped(){:tact}` and `requireStopped(){:tact}`. + +Source code: + +```tact +@interface("org.ton.stoppable") +trait Stoppable with Ownable { + stopped: Bool; + owner: Address; + + fun requireNotStopped() { + require(!self.stopped, "Contract stopped"); + } + + fun requireStopped() { + require(self.stopped, "Contract not stopped"); + } + + receive("Stop") { + self.requireOwner(); + self.requireNotStopped(); + self.stopped = true; + self.reply("Stopped".asComment()); + } + + get fun stopped(): Bool { + return self.stopped; + } +} +``` + +Usage example: + +```tact /Stoppable/ +import "@stdlib/ownable"; +import "@stdlib/stoppable"; + +contract MyContract with Stoppable { + owner: Address; + stopped: Bool; + + init(owner: Address) { + self.owner = owner; + self.stopped = false; + } +} +``` + +### Resumable + +`Resumable{:tact}` [trait](/book/types#composite-types) extends [`Stoppable{:tact}`](#stoppable) trait and allows to resume [contract](/book/contracts) execution. + +Source code: + +```tact +@interface("org.ton.resumable") +trait Resumable with Stoppable { + stopped: Bool; + owner: Address; + + receive("Resume") { + self.requireOwner(); + self.requireStopped(); + self.stopped = false; + self.reply("Resumed".asComment()); + } +} +``` + +Usage example: + +```tact /Resumable/ +import "@stdlib/ownable"; +import "@stdlib/stoppable"; + +contract MyContract with Resumable { + owner: Address; + stopped: Bool; + + init(owner: Address) { + self.owner = owner; + self.stopped = false; + } +} +``` + +## Sources + +* [stoppable.tact](https://github.com/tact-lang/tact/blob/61541b7783098e1af669faccd7d2334c10981c72/stdlib/libs/stoppable.tact) diff --git a/docs/src/env.d.ts b/docs/src/env.d.ts new file mode 100644 index 000000000..acef35f17 --- /dev/null +++ b/docs/src/env.d.ts @@ -0,0 +1,2 @@ +/// +/// diff --git a/docs/src/fonts/KaTeX_AMS-Regular.ttf b/docs/src/fonts/KaTeX_AMS-Regular.ttf new file mode 100644 index 000000000..c6f9a5e7c Binary files /dev/null and b/docs/src/fonts/KaTeX_AMS-Regular.ttf differ diff --git a/docs/src/fonts/KaTeX_AMS-Regular.woff b/docs/src/fonts/KaTeX_AMS-Regular.woff new file mode 100644 index 000000000..b804d7b33 Binary files /dev/null and b/docs/src/fonts/KaTeX_AMS-Regular.woff differ diff --git a/docs/src/fonts/KaTeX_AMS-Regular.woff2 b/docs/src/fonts/KaTeX_AMS-Regular.woff2 new file mode 100644 index 000000000..0acaaff03 Binary files /dev/null and b/docs/src/fonts/KaTeX_AMS-Regular.woff2 differ diff --git a/docs/src/fonts/KaTeX_Caligraphic-Bold.ttf b/docs/src/fonts/KaTeX_Caligraphic-Bold.ttf new file mode 100644 index 000000000..9ff4a5e04 Binary files /dev/null and b/docs/src/fonts/KaTeX_Caligraphic-Bold.ttf differ diff --git a/docs/src/fonts/KaTeX_Caligraphic-Bold.woff b/docs/src/fonts/KaTeX_Caligraphic-Bold.woff new file mode 100644 index 000000000..9759710d1 Binary files /dev/null and b/docs/src/fonts/KaTeX_Caligraphic-Bold.woff differ diff --git a/docs/src/fonts/KaTeX_Caligraphic-Bold.woff2 b/docs/src/fonts/KaTeX_Caligraphic-Bold.woff2 new file mode 100644 index 000000000..f390922ec Binary files /dev/null and b/docs/src/fonts/KaTeX_Caligraphic-Bold.woff2 differ diff --git a/docs/src/fonts/KaTeX_Caligraphic-Regular.ttf b/docs/src/fonts/KaTeX_Caligraphic-Regular.ttf new file mode 100644 index 000000000..f522294ff Binary files /dev/null and b/docs/src/fonts/KaTeX_Caligraphic-Regular.ttf differ diff --git a/docs/src/fonts/KaTeX_Caligraphic-Regular.woff b/docs/src/fonts/KaTeX_Caligraphic-Regular.woff new file mode 100644 index 000000000..9bdd534fd Binary files /dev/null and b/docs/src/fonts/KaTeX_Caligraphic-Regular.woff differ diff --git a/docs/src/fonts/KaTeX_Caligraphic-Regular.woff2 b/docs/src/fonts/KaTeX_Caligraphic-Regular.woff2 new file mode 100644 index 000000000..75344a1f9 Binary files /dev/null and b/docs/src/fonts/KaTeX_Caligraphic-Regular.woff2 differ diff --git a/docs/src/fonts/KaTeX_Fraktur-Bold.ttf b/docs/src/fonts/KaTeX_Fraktur-Bold.ttf new file mode 100644 index 000000000..4e98259c3 Binary files /dev/null and b/docs/src/fonts/KaTeX_Fraktur-Bold.ttf differ diff --git a/docs/src/fonts/KaTeX_Fraktur-Bold.woff b/docs/src/fonts/KaTeX_Fraktur-Bold.woff new file mode 100644 index 000000000..e7730f662 Binary files /dev/null and b/docs/src/fonts/KaTeX_Fraktur-Bold.woff differ diff --git a/docs/src/fonts/KaTeX_Fraktur-Bold.woff2 b/docs/src/fonts/KaTeX_Fraktur-Bold.woff2 new file mode 100644 index 000000000..395f28bea Binary files /dev/null and b/docs/src/fonts/KaTeX_Fraktur-Bold.woff2 differ diff --git a/docs/src/fonts/KaTeX_Fraktur-Regular.ttf b/docs/src/fonts/KaTeX_Fraktur-Regular.ttf new file mode 100644 index 000000000..b8461b275 Binary files /dev/null and b/docs/src/fonts/KaTeX_Fraktur-Regular.ttf differ diff --git a/docs/src/fonts/KaTeX_Fraktur-Regular.woff b/docs/src/fonts/KaTeX_Fraktur-Regular.woff new file mode 100644 index 000000000..acab069f9 Binary files /dev/null and b/docs/src/fonts/KaTeX_Fraktur-Regular.woff differ diff --git a/docs/src/fonts/KaTeX_Fraktur-Regular.woff2 b/docs/src/fonts/KaTeX_Fraktur-Regular.woff2 new file mode 100644 index 000000000..735f6948d Binary files /dev/null and b/docs/src/fonts/KaTeX_Fraktur-Regular.woff2 differ diff --git a/docs/src/fonts/KaTeX_Main-Bold.ttf b/docs/src/fonts/KaTeX_Main-Bold.ttf new file mode 100644 index 000000000..4060e627d Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-Bold.ttf differ diff --git a/docs/src/fonts/KaTeX_Main-Bold.woff b/docs/src/fonts/KaTeX_Main-Bold.woff new file mode 100644 index 000000000..f38136ac1 Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-Bold.woff differ diff --git a/docs/src/fonts/KaTeX_Main-Bold.woff2 b/docs/src/fonts/KaTeX_Main-Bold.woff2 new file mode 100644 index 000000000..ab2ad21da Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-Bold.woff2 differ diff --git a/docs/src/fonts/KaTeX_Main-BoldItalic.ttf b/docs/src/fonts/KaTeX_Main-BoldItalic.ttf new file mode 100644 index 000000000..dc007977e Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-BoldItalic.ttf differ diff --git a/docs/src/fonts/KaTeX_Main-BoldItalic.woff b/docs/src/fonts/KaTeX_Main-BoldItalic.woff new file mode 100644 index 000000000..67807b0bd Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-BoldItalic.woff differ diff --git a/docs/src/fonts/KaTeX_Main-BoldItalic.woff2 b/docs/src/fonts/KaTeX_Main-BoldItalic.woff2 new file mode 100644 index 000000000..5931794de Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-BoldItalic.woff2 differ diff --git a/docs/src/fonts/KaTeX_Main-Italic.ttf b/docs/src/fonts/KaTeX_Main-Italic.ttf new file mode 100644 index 000000000..0e9b0f354 Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-Italic.ttf differ diff --git a/docs/src/fonts/KaTeX_Main-Italic.woff b/docs/src/fonts/KaTeX_Main-Italic.woff new file mode 100644 index 000000000..6f43b594b Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-Italic.woff differ diff --git a/docs/src/fonts/KaTeX_Main-Italic.woff2 b/docs/src/fonts/KaTeX_Main-Italic.woff2 new file mode 100644 index 000000000..b50920e13 Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-Italic.woff2 differ diff --git a/docs/src/fonts/KaTeX_Main-Regular.ttf b/docs/src/fonts/KaTeX_Main-Regular.ttf new file mode 100644 index 000000000..dd45e1ed2 Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-Regular.ttf differ diff --git a/docs/src/fonts/KaTeX_Main-Regular.woff b/docs/src/fonts/KaTeX_Main-Regular.woff new file mode 100644 index 000000000..21f581296 Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-Regular.woff differ diff --git a/docs/src/fonts/KaTeX_Main-Regular.woff2 b/docs/src/fonts/KaTeX_Main-Regular.woff2 new file mode 100644 index 000000000..eb24a7ba2 Binary files /dev/null and b/docs/src/fonts/KaTeX_Main-Regular.woff2 differ diff --git a/docs/src/fonts/KaTeX_Math-BoldItalic.ttf b/docs/src/fonts/KaTeX_Math-BoldItalic.ttf new file mode 100644 index 000000000..728ce7a1e Binary files /dev/null and b/docs/src/fonts/KaTeX_Math-BoldItalic.ttf differ diff --git a/docs/src/fonts/KaTeX_Math-BoldItalic.woff b/docs/src/fonts/KaTeX_Math-BoldItalic.woff new file mode 100644 index 000000000..0ae390d74 Binary files /dev/null and b/docs/src/fonts/KaTeX_Math-BoldItalic.woff differ diff --git a/docs/src/fonts/KaTeX_Math-BoldItalic.woff2 b/docs/src/fonts/KaTeX_Math-BoldItalic.woff2 new file mode 100644 index 000000000..29657023a Binary files /dev/null and b/docs/src/fonts/KaTeX_Math-BoldItalic.woff2 differ diff --git a/docs/src/fonts/KaTeX_Math-Italic.ttf b/docs/src/fonts/KaTeX_Math-Italic.ttf new file mode 100644 index 000000000..70d559b4e Binary files /dev/null and b/docs/src/fonts/KaTeX_Math-Italic.ttf differ diff --git a/docs/src/fonts/KaTeX_Math-Italic.woff b/docs/src/fonts/KaTeX_Math-Italic.woff new file mode 100644 index 000000000..eb5159d4c Binary files /dev/null and b/docs/src/fonts/KaTeX_Math-Italic.woff differ diff --git a/docs/src/fonts/KaTeX_Math-Italic.woff2 b/docs/src/fonts/KaTeX_Math-Italic.woff2 new file mode 100644 index 000000000..215c143fd Binary files /dev/null and b/docs/src/fonts/KaTeX_Math-Italic.woff2 differ diff --git a/docs/src/fonts/KaTeX_SansSerif-Bold.ttf b/docs/src/fonts/KaTeX_SansSerif-Bold.ttf new file mode 100644 index 000000000..2f65a8a3a Binary files /dev/null and b/docs/src/fonts/KaTeX_SansSerif-Bold.ttf differ diff --git a/docs/src/fonts/KaTeX_SansSerif-Bold.woff b/docs/src/fonts/KaTeX_SansSerif-Bold.woff new file mode 100644 index 000000000..8d47c02d9 Binary files /dev/null and b/docs/src/fonts/KaTeX_SansSerif-Bold.woff differ diff --git a/docs/src/fonts/KaTeX_SansSerif-Bold.woff2 b/docs/src/fonts/KaTeX_SansSerif-Bold.woff2 new file mode 100644 index 000000000..cfaa3bda5 Binary files /dev/null and b/docs/src/fonts/KaTeX_SansSerif-Bold.woff2 differ diff --git a/docs/src/fonts/KaTeX_SansSerif-Italic.ttf b/docs/src/fonts/KaTeX_SansSerif-Italic.ttf new file mode 100644 index 000000000..d5850df98 Binary files /dev/null and b/docs/src/fonts/KaTeX_SansSerif-Italic.ttf differ diff --git a/docs/src/fonts/KaTeX_SansSerif-Italic.woff b/docs/src/fonts/KaTeX_SansSerif-Italic.woff new file mode 100644 index 000000000..7e02df963 Binary files /dev/null and b/docs/src/fonts/KaTeX_SansSerif-Italic.woff differ diff --git a/docs/src/fonts/KaTeX_SansSerif-Italic.woff2 b/docs/src/fonts/KaTeX_SansSerif-Italic.woff2 new file mode 100644 index 000000000..349c06dc6 Binary files /dev/null and b/docs/src/fonts/KaTeX_SansSerif-Italic.woff2 differ diff --git a/docs/src/fonts/KaTeX_SansSerif-Regular.ttf b/docs/src/fonts/KaTeX_SansSerif-Regular.ttf new file mode 100644 index 000000000..537279f6b Binary files /dev/null and b/docs/src/fonts/KaTeX_SansSerif-Regular.ttf differ diff --git a/docs/src/fonts/KaTeX_SansSerif-Regular.woff b/docs/src/fonts/KaTeX_SansSerif-Regular.woff new file mode 100644 index 000000000..31b84829b Binary files /dev/null and b/docs/src/fonts/KaTeX_SansSerif-Regular.woff differ diff --git a/docs/src/fonts/KaTeX_SansSerif-Regular.woff2 b/docs/src/fonts/KaTeX_SansSerif-Regular.woff2 new file mode 100644 index 000000000..a90eea85f Binary files /dev/null and b/docs/src/fonts/KaTeX_SansSerif-Regular.woff2 differ diff --git a/docs/src/fonts/KaTeX_Script-Regular.ttf b/docs/src/fonts/KaTeX_Script-Regular.ttf new file mode 100644 index 000000000..fd679bf37 Binary files /dev/null and b/docs/src/fonts/KaTeX_Script-Regular.ttf differ diff --git a/docs/src/fonts/KaTeX_Script-Regular.woff b/docs/src/fonts/KaTeX_Script-Regular.woff new file mode 100644 index 000000000..0e7da821e Binary files /dev/null and b/docs/src/fonts/KaTeX_Script-Regular.woff differ diff --git a/docs/src/fonts/KaTeX_Script-Regular.woff2 b/docs/src/fonts/KaTeX_Script-Regular.woff2 new file mode 100644 index 000000000..b3048fc11 Binary files /dev/null and b/docs/src/fonts/KaTeX_Script-Regular.woff2 differ diff --git a/docs/src/fonts/KaTeX_Size1-Regular.ttf b/docs/src/fonts/KaTeX_Size1-Regular.ttf new file mode 100644 index 000000000..871fd7d19 Binary files /dev/null and b/docs/src/fonts/KaTeX_Size1-Regular.ttf differ diff --git a/docs/src/fonts/KaTeX_Size1-Regular.woff b/docs/src/fonts/KaTeX_Size1-Regular.woff new file mode 100644 index 000000000..7f292d911 Binary files /dev/null and b/docs/src/fonts/KaTeX_Size1-Regular.woff differ diff --git a/docs/src/fonts/KaTeX_Size1-Regular.woff2 b/docs/src/fonts/KaTeX_Size1-Regular.woff2 new file mode 100644 index 000000000..c5a8462fb Binary files /dev/null and b/docs/src/fonts/KaTeX_Size1-Regular.woff2 differ diff --git a/docs/src/fonts/KaTeX_Size2-Regular.ttf b/docs/src/fonts/KaTeX_Size2-Regular.ttf new file mode 100644 index 000000000..7a212caf9 Binary files /dev/null and b/docs/src/fonts/KaTeX_Size2-Regular.ttf differ diff --git a/docs/src/fonts/KaTeX_Size2-Regular.woff b/docs/src/fonts/KaTeX_Size2-Regular.woff new file mode 100644 index 000000000..d241d9be2 Binary files /dev/null and b/docs/src/fonts/KaTeX_Size2-Regular.woff differ diff --git a/docs/src/fonts/KaTeX_Size2-Regular.woff2 b/docs/src/fonts/KaTeX_Size2-Regular.woff2 new file mode 100644 index 000000000..e1bccfe24 Binary files /dev/null and b/docs/src/fonts/KaTeX_Size2-Regular.woff2 differ diff --git a/docs/src/fonts/KaTeX_Size3-Regular.ttf b/docs/src/fonts/KaTeX_Size3-Regular.ttf new file mode 100644 index 000000000..00bff3495 Binary files /dev/null and b/docs/src/fonts/KaTeX_Size3-Regular.ttf differ diff --git a/docs/src/fonts/KaTeX_Size3-Regular.woff b/docs/src/fonts/KaTeX_Size3-Regular.woff new file mode 100644 index 000000000..e6e9b658d Binary files /dev/null and b/docs/src/fonts/KaTeX_Size3-Regular.woff differ diff --git a/docs/src/fonts/KaTeX_Size3-Regular.woff2 b/docs/src/fonts/KaTeX_Size3-Regular.woff2 new file mode 100644 index 000000000..249a28662 Binary files /dev/null and b/docs/src/fonts/KaTeX_Size3-Regular.woff2 differ diff --git a/docs/src/fonts/KaTeX_Size4-Regular.ttf b/docs/src/fonts/KaTeX_Size4-Regular.ttf new file mode 100644 index 000000000..74f08921f Binary files /dev/null and b/docs/src/fonts/KaTeX_Size4-Regular.ttf differ diff --git a/docs/src/fonts/KaTeX_Size4-Regular.woff b/docs/src/fonts/KaTeX_Size4-Regular.woff new file mode 100644 index 000000000..e1ec54576 Binary files /dev/null and b/docs/src/fonts/KaTeX_Size4-Regular.woff differ diff --git a/docs/src/fonts/KaTeX_Size4-Regular.woff2 b/docs/src/fonts/KaTeX_Size4-Regular.woff2 new file mode 100644 index 000000000..680c13085 Binary files /dev/null and b/docs/src/fonts/KaTeX_Size4-Regular.woff2 differ diff --git a/docs/src/fonts/KaTeX_Typewriter-Regular.ttf b/docs/src/fonts/KaTeX_Typewriter-Regular.ttf new file mode 100644 index 000000000..c83252c57 Binary files /dev/null and b/docs/src/fonts/KaTeX_Typewriter-Regular.ttf differ diff --git a/docs/src/fonts/KaTeX_Typewriter-Regular.woff b/docs/src/fonts/KaTeX_Typewriter-Regular.woff new file mode 100644 index 000000000..2432419f2 Binary files /dev/null and b/docs/src/fonts/KaTeX_Typewriter-Regular.woff differ diff --git a/docs/src/fonts/KaTeX_Typewriter-Regular.woff2 b/docs/src/fonts/KaTeX_Typewriter-Regular.woff2 new file mode 100644 index 000000000..771f1af70 Binary files /dev/null and b/docs/src/fonts/KaTeX_Typewriter-Regular.woff2 differ diff --git a/docs/src/fonts/katex.fontfaces.css b/docs/src/fonts/katex.fontfaces.css new file mode 100644 index 000000000..6e2e68570 --- /dev/null +++ b/docs/src/fonts/katex.fontfaces.css @@ -0,0 +1 @@ +@font-face{font-family:KaTeX_AMS;font-style:normal;font-weight:400;src:url(KaTeX_AMS-Regular.woff2) format("woff2"),url(KaTeX_AMS-Regular.woff) format("woff"),url(KaTeX_AMS-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Caligraphic;font-style:normal;font-weight:700;src:url(KaTeX_Caligraphic-Bold.woff2) format("woff2"),url(KaTeX_Caligraphic-Bold.woff) format("woff"),url(KaTeX_Caligraphic-Bold.ttf) format("truetype")}@font-face{font-family:KaTeX_Caligraphic;font-style:normal;font-weight:400;src:url(KaTeX_Caligraphic-Regular.woff2) format("woff2"),url(KaTeX_Caligraphic-Regular.woff) format("woff"),url(KaTeX_Caligraphic-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Fraktur;font-style:normal;font-weight:700;src:url(KaTeX_Fraktur-Bold.woff2) format("woff2"),url(KaTeX_Fraktur-Bold.woff) format("woff"),url(KaTeX_Fraktur-Bold.ttf) format("truetype")}@font-face{font-family:KaTeX_Fraktur;font-style:normal;font-weight:400;src:url(KaTeX_Fraktur-Regular.woff2) format("woff2"),url(KaTeX_Fraktur-Regular.woff) format("woff"),url(KaTeX_Fraktur-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Main;font-style:normal;font-weight:700;src:url(KaTeX_Main-Bold.woff2) format("woff2"),url(KaTeX_Main-Bold.woff) format("woff"),url(KaTeX_Main-Bold.ttf) format("truetype")}@font-face{font-family:KaTeX_Main;font-style:italic;font-weight:700;src:url(KaTeX_Main-BoldItalic.woff2) format("woff2"),url(KaTeX_Main-BoldItalic.woff) format("woff"),url(KaTeX_Main-BoldItalic.ttf) format("truetype")}@font-face{font-family:KaTeX_Main;font-style:italic;font-weight:400;src:url(KaTeX_Main-Italic.woff2) format("woff2"),url(KaTeX_Main-Italic.woff) format("woff"),url(KaTeX_Main-Italic.ttf) format("truetype")}@font-face{font-family:KaTeX_Main;font-style:normal;font-weight:400;src:url(KaTeX_Main-Regular.woff2) format("woff2"),url(KaTeX_Main-Regular.woff) format("woff"),url(KaTeX_Main-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Math;font-style:italic;font-weight:700;src:url(KaTeX_Math-BoldItalic.woff2) format("woff2"),url(KaTeX_Math-BoldItalic.woff) format("woff"),url(KaTeX_Math-BoldItalic.ttf) format("truetype")}@font-face{font-family:KaTeX_Math;font-style:italic;font-weight:400;src:url(KaTeX_Math-Italic.woff2) format("woff2"),url(KaTeX_Math-Italic.woff) format("woff"),url(KaTeX_Math-Italic.ttf) format("truetype")}@font-face{font-family:"KaTeX_SansSerif";font-style:normal;font-weight:700;src:url(KaTeX_SansSerif-Bold.woff2) format("woff2"),url(KaTeX_SansSerif-Bold.woff) format("woff"),url(KaTeX_SansSerif-Bold.ttf) format("truetype")}@font-face{font-family:"KaTeX_SansSerif";font-style:italic;font-weight:400;src:url(KaTeX_SansSerif-Italic.woff2) format("woff2"),url(KaTeX_SansSerif-Italic.woff) format("woff"),url(KaTeX_SansSerif-Italic.ttf) format("truetype")}@font-face{font-family:"KaTeX_SansSerif";font-style:normal;font-weight:400;src:url(KaTeX_SansSerif-Regular.woff2) format("woff2"),url(KaTeX_SansSerif-Regular.woff) format("woff"),url(KaTeX_SansSerif-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Script;font-style:normal;font-weight:400;src:url(KaTeX_Script-Regular.woff2) format("woff2"),url(KaTeX_Script-Regular.woff) format("woff"),url(KaTeX_Script-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Size1;font-style:normal;font-weight:400;src:url(KaTeX_Size1-Regular.woff2) format("woff2"),url(KaTeX_Size1-Regular.woff) format("woff"),url(KaTeX_Size1-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Size2;font-style:normal;font-weight:400;src:url(KaTeX_Size2-Regular.woff2) format("woff2"),url(KaTeX_Size2-Regular.woff) format("woff"),url(KaTeX_Size2-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Size3;font-style:normal;font-weight:400;src:url(KaTeX_Size3-Regular.woff2) format("woff2"),url(KaTeX_Size3-Regular.woff) format("woff"),url(KaTeX_Size3-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Size4;font-style:normal;font-weight:400;src:url(KaTeX_Size4-Regular.woff2) format("woff2"),url(KaTeX_Size4-Regular.woff) format("woff"),url(KaTeX_Size4-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Typewriter;font-style:normal;font-weight:400;src:url(KaTeX_Typewriter-Regular.woff2) format("woff2"),url(KaTeX_Typewriter-Regular.woff) format("woff"),url(fonts/KaTeX_Typewriter-Regular.ttf) format("truetype")} diff --git a/docs/src/katex.min.css b/docs/src/katex.min.css new file mode 100644 index 000000000..a6b898770 --- /dev/null +++ b/docs/src/katex.min.css @@ -0,0 +1 @@ +.katex{font:normal 1.21em KaTeX_Main,Times New Roman,serif;line-height:1.2;text-indent:0;text-rendering:auto}.katex *{-ms-high-contrast-adjust:none!important;border-color:currentColor}.katex .katex-version:after{content:"0.16.11"}.katex .katex-mathml{clip:rect(1px,1px,1px,1px);border:0;height:1px;overflow:hidden;padding:0;position:absolute;width:1px}.katex .katex-html>.newline{display:block}.katex .base{position:relative;white-space:nowrap;width:-webkit-min-content;width:-moz-min-content;width:min-content}.katex .base,.katex .strut{display:inline-block}.katex .textbf{font-weight:700}.katex .textit{font-style:italic}.katex .textrm{font-family:KaTeX_Main}.katex .textsf{font-family:KaTeX_SansSerif}.katex .texttt{font-family:KaTeX_Typewriter}.katex .mathnormal{font-family:KaTeX_Math;font-style:italic}.katex .mathit{font-family:KaTeX_Main;font-style:italic}.katex .mathrm{font-style:normal}.katex .mathbf{font-family:KaTeX_Main;font-weight:700}.katex .boldsymbol{font-family:KaTeX_Math;font-style:italic;font-weight:700}.katex .amsrm,.katex .mathbb,.katex .textbb{font-family:KaTeX_AMS}.katex .mathcal{font-family:KaTeX_Caligraphic}.katex .mathfrak,.katex .textfrak{font-family:KaTeX_Fraktur}.katex .mathboldfrak,.katex .textboldfrak{font-family:KaTeX_Fraktur;font-weight:700}.katex .mathtt{font-family:KaTeX_Typewriter}.katex .mathscr,.katex .textscr{font-family:KaTeX_Script}.katex .mathsf,.katex .textsf{font-family:KaTeX_SansSerif}.katex .mathboldsf,.katex .textboldsf{font-family:KaTeX_SansSerif;font-weight:700}.katex .mathitsf,.katex .textitsf{font-family:KaTeX_SansSerif;font-style:italic}.katex .mainrm{font-family:KaTeX_Main;font-style:normal}.katex .vlist-t{border-collapse:collapse;display:inline-table;table-layout:fixed}.katex .vlist-r{display:table-row}.katex .vlist{display:table-cell;position:relative;vertical-align:bottom}.katex .vlist>span{display:block;height:0;position:relative}.katex .vlist>span>span{display:inline-block}.katex .vlist>span>.pstrut{overflow:hidden;width:0}.katex .vlist-t2{margin-right:-2px}.katex .vlist-s{display:table-cell;font-size:1px;min-width:2px;vertical-align:bottom;width:2px}.katex .vbox{align-items:baseline;display:inline-flex;flex-direction:column}.katex .hbox{width:100%}.katex .hbox,.katex .thinbox{display:inline-flex;flex-direction:row}.katex .thinbox{max-width:0;width:0}.katex .msupsub{text-align:left}.katex .mfrac>span>span{text-align:center}.katex .mfrac .frac-line{border-bottom-style:solid;display:inline-block;width:100%}.katex .hdashline,.katex .hline,.katex .mfrac .frac-line,.katex .overline .overline-line,.katex .rule,.katex .underline .underline-line{min-height:1px}.katex .mspace{display:inline-block}.katex .clap,.katex .llap,.katex .rlap{position:relative;width:0}.katex .clap>.inner,.katex .llap>.inner,.katex .rlap>.inner{position:absolute}.katex .clap>.fix,.katex .llap>.fix,.katex .rlap>.fix{display:inline-block}.katex .llap>.inner{right:0}.katex .clap>.inner,.katex .rlap>.inner{left:0}.katex .clap>.inner>span{margin-left:-50%;margin-right:50%}.katex .rule{border:0 solid;display:inline-block;position:relative}.katex .hline,.katex .overline .overline-line,.katex .underline .underline-line{border-bottom-style:solid;display:inline-block;width:100%}.katex .hdashline{border-bottom-style:dashed;display:inline-block;width:100%}.katex .sqrt>.root{margin-left:.2777777778em;margin-right:-.5555555556em}.katex .fontsize-ensurer.reset-size1.size1,.katex .sizing.reset-size1.size1{font-size:1em}.katex .fontsize-ensurer.reset-size1.size2,.katex .sizing.reset-size1.size2{font-size:1.2em}.katex .fontsize-ensurer.reset-size1.size3,.katex .sizing.reset-size1.size3{font-size:1.4em}.katex .fontsize-ensurer.reset-size1.size4,.katex .sizing.reset-size1.size4{font-size:1.6em}.katex .fontsize-ensurer.reset-size1.size5,.katex .sizing.reset-size1.size5{font-size:1.8em}.katex .fontsize-ensurer.reset-size1.size6,.katex .sizing.reset-size1.size6{font-size:2em}.katex .fontsize-ensurer.reset-size1.size7,.katex .sizing.reset-size1.size7{font-size:2.4em}.katex .fontsize-ensurer.reset-size1.size8,.katex .sizing.reset-size1.size8{font-size:2.88em}.katex .fontsize-ensurer.reset-size1.size9,.katex .sizing.reset-size1.size9{font-size:3.456em}.katex .fontsize-ensurer.reset-size1.size10,.katex .sizing.reset-size1.size10{font-size:4.148em}.katex .fontsize-ensurer.reset-size1.size11,.katex .sizing.reset-size1.size11{font-size:4.976em}.katex .fontsize-ensurer.reset-size2.size1,.katex .sizing.reset-size2.size1{font-size:.8333333333em}.katex .fontsize-ensurer.reset-size2.size2,.katex .sizing.reset-size2.size2{font-size:1em}.katex .fontsize-ensurer.reset-size2.size3,.katex .sizing.reset-size2.size3{font-size:1.1666666667em}.katex .fontsize-ensurer.reset-size2.size4,.katex .sizing.reset-size2.size4{font-size:1.3333333333em}.katex .fontsize-ensurer.reset-size2.size5,.katex .sizing.reset-size2.size5{font-size:1.5em}.katex .fontsize-ensurer.reset-size2.size6,.katex .sizing.reset-size2.size6{font-size:1.6666666667em}.katex .fontsize-ensurer.reset-size2.size7,.katex .sizing.reset-size2.size7{font-size:2em}.katex .fontsize-ensurer.reset-size2.size8,.katex .sizing.reset-size2.size8{font-size:2.4em}.katex .fontsize-ensurer.reset-size2.size9,.katex .sizing.reset-size2.size9{font-size:2.88em}.katex .fontsize-ensurer.reset-size2.size10,.katex .sizing.reset-size2.size10{font-size:3.4566666667em}.katex .fontsize-ensurer.reset-size2.size11,.katex .sizing.reset-size2.size11{font-size:4.1466666667em}.katex .fontsize-ensurer.reset-size3.size1,.katex .sizing.reset-size3.size1{font-size:.7142857143em}.katex .fontsize-ensurer.reset-size3.size2,.katex .sizing.reset-size3.size2{font-size:.8571428571em}.katex .fontsize-ensurer.reset-size3.size3,.katex .sizing.reset-size3.size3{font-size:1em}.katex .fontsize-ensurer.reset-size3.size4,.katex .sizing.reset-size3.size4{font-size:1.1428571429em}.katex .fontsize-ensurer.reset-size3.size5,.katex .sizing.reset-size3.size5{font-size:1.2857142857em}.katex .fontsize-ensurer.reset-size3.size6,.katex .sizing.reset-size3.size6{font-size:1.4285714286em}.katex .fontsize-ensurer.reset-size3.size7,.katex .sizing.reset-size3.size7{font-size:1.7142857143em}.katex .fontsize-ensurer.reset-size3.size8,.katex .sizing.reset-size3.size8{font-size:2.0571428571em}.katex .fontsize-ensurer.reset-size3.size9,.katex .sizing.reset-size3.size9{font-size:2.4685714286em}.katex .fontsize-ensurer.reset-size3.size10,.katex .sizing.reset-size3.size10{font-size:2.9628571429em}.katex .fontsize-ensurer.reset-size3.size11,.katex .sizing.reset-size3.size11{font-size:3.5542857143em}.katex .fontsize-ensurer.reset-size4.size1,.katex .sizing.reset-size4.size1{font-size:.625em}.katex .fontsize-ensurer.reset-size4.size2,.katex .sizing.reset-size4.size2{font-size:.75em}.katex .fontsize-ensurer.reset-size4.size3,.katex .sizing.reset-size4.size3{font-size:.875em}.katex .fontsize-ensurer.reset-size4.size4,.katex .sizing.reset-size4.size4{font-size:1em}.katex .fontsize-ensurer.reset-size4.size5,.katex .sizing.reset-size4.size5{font-size:1.125em}.katex .fontsize-ensurer.reset-size4.size6,.katex .sizing.reset-size4.size6{font-size:1.25em}.katex .fontsize-ensurer.reset-size4.size7,.katex .sizing.reset-size4.size7{font-size:1.5em}.katex .fontsize-ensurer.reset-size4.size8,.katex .sizing.reset-size4.size8{font-size:1.8em}.katex .fontsize-ensurer.reset-size4.size9,.katex .sizing.reset-size4.size9{font-size:2.16em}.katex .fontsize-ensurer.reset-size4.size10,.katex .sizing.reset-size4.size10{font-size:2.5925em}.katex .fontsize-ensurer.reset-size4.size11,.katex .sizing.reset-size4.size11{font-size:3.11em}.katex .fontsize-ensurer.reset-size5.size1,.katex .sizing.reset-size5.size1{font-size:.5555555556em}.katex .fontsize-ensurer.reset-size5.size2,.katex .sizing.reset-size5.size2{font-size:.6666666667em}.katex .fontsize-ensurer.reset-size5.size3,.katex .sizing.reset-size5.size3{font-size:.7777777778em}.katex .fontsize-ensurer.reset-size5.size4,.katex .sizing.reset-size5.size4{font-size:.8888888889em}.katex .fontsize-ensurer.reset-size5.size5,.katex .sizing.reset-size5.size5{font-size:1em}.katex .fontsize-ensurer.reset-size5.size6,.katex .sizing.reset-size5.size6{font-size:1.1111111111em}.katex .fontsize-ensurer.reset-size5.size7,.katex .sizing.reset-size5.size7{font-size:1.3333333333em}.katex .fontsize-ensurer.reset-size5.size8,.katex .sizing.reset-size5.size8{font-size:1.6em}.katex .fontsize-ensurer.reset-size5.size9,.katex .sizing.reset-size5.size9{font-size:1.92em}.katex .fontsize-ensurer.reset-size5.size10,.katex .sizing.reset-size5.size10{font-size:2.3044444444em}.katex .fontsize-ensurer.reset-size5.size11,.katex .sizing.reset-size5.size11{font-size:2.7644444444em}.katex .fontsize-ensurer.reset-size6.size1,.katex .sizing.reset-size6.size1{font-size:.5em}.katex .fontsize-ensurer.reset-size6.size2,.katex .sizing.reset-size6.size2{font-size:.6em}.katex .fontsize-ensurer.reset-size6.size3,.katex .sizing.reset-size6.size3{font-size:.7em}.katex .fontsize-ensurer.reset-size6.size4,.katex .sizing.reset-size6.size4{font-size:.8em}.katex .fontsize-ensurer.reset-size6.size5,.katex .sizing.reset-size6.size5{font-size:.9em}.katex .fontsize-ensurer.reset-size6.size6,.katex .sizing.reset-size6.size6{font-size:1em}.katex .fontsize-ensurer.reset-size6.size7,.katex .sizing.reset-size6.size7{font-size:1.2em}.katex .fontsize-ensurer.reset-size6.size8,.katex .sizing.reset-size6.size8{font-size:1.44em}.katex .fontsize-ensurer.reset-size6.size9,.katex .sizing.reset-size6.size9{font-size:1.728em}.katex .fontsize-ensurer.reset-size6.size10,.katex .sizing.reset-size6.size10{font-size:2.074em}.katex .fontsize-ensurer.reset-size6.size11,.katex .sizing.reset-size6.size11{font-size:2.488em}.katex .fontsize-ensurer.reset-size7.size1,.katex .sizing.reset-size7.size1{font-size:.4166666667em}.katex .fontsize-ensurer.reset-size7.size2,.katex .sizing.reset-size7.size2{font-size:.5em}.katex .fontsize-ensurer.reset-size7.size3,.katex .sizing.reset-size7.size3{font-size:.5833333333em}.katex .fontsize-ensurer.reset-size7.size4,.katex .sizing.reset-size7.size4{font-size:.6666666667em}.katex .fontsize-ensurer.reset-size7.size5,.katex .sizing.reset-size7.size5{font-size:.75em}.katex .fontsize-ensurer.reset-size7.size6,.katex .sizing.reset-size7.size6{font-size:.8333333333em}.katex .fontsize-ensurer.reset-size7.size7,.katex .sizing.reset-size7.size7{font-size:1em}.katex .fontsize-ensurer.reset-size7.size8,.katex .sizing.reset-size7.size8{font-size:1.2em}.katex .fontsize-ensurer.reset-size7.size9,.katex .sizing.reset-size7.size9{font-size:1.44em}.katex .fontsize-ensurer.reset-size7.size10,.katex .sizing.reset-size7.size10{font-size:1.7283333333em}.katex .fontsize-ensurer.reset-size7.size11,.katex .sizing.reset-size7.size11{font-size:2.0733333333em}.katex .fontsize-ensurer.reset-size8.size1,.katex .sizing.reset-size8.size1{font-size:.3472222222em}.katex .fontsize-ensurer.reset-size8.size2,.katex .sizing.reset-size8.size2{font-size:.4166666667em}.katex .fontsize-ensurer.reset-size8.size3,.katex .sizing.reset-size8.size3{font-size:.4861111111em}.katex .fontsize-ensurer.reset-size8.size4,.katex .sizing.reset-size8.size4{font-size:.5555555556em}.katex .fontsize-ensurer.reset-size8.size5,.katex .sizing.reset-size8.size5{font-size:.625em}.katex .fontsize-ensurer.reset-size8.size6,.katex .sizing.reset-size8.size6{font-size:.6944444444em}.katex .fontsize-ensurer.reset-size8.size7,.katex .sizing.reset-size8.size7{font-size:.8333333333em}.katex .fontsize-ensurer.reset-size8.size8,.katex .sizing.reset-size8.size8{font-size:1em}.katex .fontsize-ensurer.reset-size8.size9,.katex .sizing.reset-size8.size9{font-size:1.2em}.katex .fontsize-ensurer.reset-size8.size10,.katex .sizing.reset-size8.size10{font-size:1.4402777778em}.katex .fontsize-ensurer.reset-size8.size11,.katex .sizing.reset-size8.size11{font-size:1.7277777778em}.katex .fontsize-ensurer.reset-size9.size1,.katex .sizing.reset-size9.size1{font-size:.2893518519em}.katex .fontsize-ensurer.reset-size9.size2,.katex .sizing.reset-size9.size2{font-size:.3472222222em}.katex .fontsize-ensurer.reset-size9.size3,.katex .sizing.reset-size9.size3{font-size:.4050925926em}.katex .fontsize-ensurer.reset-size9.size4,.katex .sizing.reset-size9.size4{font-size:.462962963em}.katex .fontsize-ensurer.reset-size9.size5,.katex .sizing.reset-size9.size5{font-size:.5208333333em}.katex .fontsize-ensurer.reset-size9.size6,.katex .sizing.reset-size9.size6{font-size:.5787037037em}.katex .fontsize-ensurer.reset-size9.size7,.katex .sizing.reset-size9.size7{font-size:.6944444444em}.katex .fontsize-ensurer.reset-size9.size8,.katex .sizing.reset-size9.size8{font-size:.8333333333em}.katex .fontsize-ensurer.reset-size9.size9,.katex .sizing.reset-size9.size9{font-size:1em}.katex .fontsize-ensurer.reset-size9.size10,.katex .sizing.reset-size9.size10{font-size:1.2002314815em}.katex .fontsize-ensurer.reset-size9.size11,.katex .sizing.reset-size9.size11{font-size:1.4398148148em}.katex .fontsize-ensurer.reset-size10.size1,.katex .sizing.reset-size10.size1{font-size:.2410800386em}.katex .fontsize-ensurer.reset-size10.size2,.katex .sizing.reset-size10.size2{font-size:.2892960463em}.katex .fontsize-ensurer.reset-size10.size3,.katex .sizing.reset-size10.size3{font-size:.337512054em}.katex .fontsize-ensurer.reset-size10.size4,.katex .sizing.reset-size10.size4{font-size:.3857280617em}.katex .fontsize-ensurer.reset-size10.size5,.katex .sizing.reset-size10.size5{font-size:.4339440694em}.katex .fontsize-ensurer.reset-size10.size6,.katex .sizing.reset-size10.size6{font-size:.4821600771em}.katex .fontsize-ensurer.reset-size10.size7,.katex .sizing.reset-size10.size7{font-size:.5785920926em}.katex .fontsize-ensurer.reset-size10.size8,.katex .sizing.reset-size10.size8{font-size:.6943105111em}.katex .fontsize-ensurer.reset-size10.size9,.katex .sizing.reset-size10.size9{font-size:.8331726133em}.katex .fontsize-ensurer.reset-size10.size10,.katex .sizing.reset-size10.size10{font-size:1em}.katex .fontsize-ensurer.reset-size10.size11,.katex .sizing.reset-size10.size11{font-size:1.1996142719em}.katex .fontsize-ensurer.reset-size11.size1,.katex .sizing.reset-size11.size1{font-size:.2009646302em}.katex .fontsize-ensurer.reset-size11.size2,.katex .sizing.reset-size11.size2{font-size:.2411575563em}.katex .fontsize-ensurer.reset-size11.size3,.katex .sizing.reset-size11.size3{font-size:.2813504823em}.katex .fontsize-ensurer.reset-size11.size4,.katex .sizing.reset-size11.size4{font-size:.3215434084em}.katex .fontsize-ensurer.reset-size11.size5,.katex .sizing.reset-size11.size5{font-size:.3617363344em}.katex .fontsize-ensurer.reset-size11.size6,.katex .sizing.reset-size11.size6{font-size:.4019292605em}.katex .fontsize-ensurer.reset-size11.size7,.katex .sizing.reset-size11.size7{font-size:.4823151125em}.katex .fontsize-ensurer.reset-size11.size8,.katex .sizing.reset-size11.size8{font-size:.578778135em}.katex .fontsize-ensurer.reset-size11.size9,.katex .sizing.reset-size11.size9{font-size:.6945337621em}.katex .fontsize-ensurer.reset-size11.size10,.katex .sizing.reset-size11.size10{font-size:.8336012862em}.katex .fontsize-ensurer.reset-size11.size11,.katex .sizing.reset-size11.size11{font-size:1em}.katex .delimsizing.size1{font-family:KaTeX_Size1}.katex .delimsizing.size2{font-family:KaTeX_Size2}.katex .delimsizing.size3{font-family:KaTeX_Size3}.katex .delimsizing.size4{font-family:KaTeX_Size4}.katex .delimsizing.mult .delim-size1>span{font-family:KaTeX_Size1}.katex .delimsizing.mult .delim-size4>span{font-family:KaTeX_Size4}.katex .nulldelimiter{display:inline-block;width:.12em}.katex .delimcenter,.katex .op-symbol{position:relative}.katex .op-symbol.small-op{font-family:KaTeX_Size1}.katex .op-symbol.large-op{font-family:KaTeX_Size2}.katex .accent>.vlist-t,.katex .op-limits>.vlist-t{text-align:center}.katex .accent .accent-body{position:relative}.katex .accent .accent-body:not(.accent-full){width:0}.katex .overlay{display:block}.katex .mtable .vertical-separator{display:inline-block;min-width:1px}.katex .mtable .arraycolsep{display:inline-block}.katex .mtable .col-align-c>.vlist-t{text-align:center}.katex .mtable .col-align-l>.vlist-t{text-align:left}.katex .mtable .col-align-r>.vlist-t{text-align:right}.katex .svg-align{text-align:left}.katex svg{fill:currentColor;stroke:currentColor;fill-rule:nonzero;fill-opacity:1;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;display:block;height:inherit;position:absolute;width:100%}.katex svg path{stroke:none}.katex img{border-style:none;max-height:none;max-width:none;min-height:0;min-width:0}.katex .stretchy{display:block;overflow:hidden;position:relative;width:100%}.katex .stretchy:after,.katex .stretchy:before{content:""}.katex .hide-tail{overflow:hidden;position:relative;width:100%}.katex .halfarrow-left{left:0;overflow:hidden;position:absolute;width:50.2%}.katex .halfarrow-right{overflow:hidden;position:absolute;right:0;width:50.2%}.katex .brace-left{left:0;overflow:hidden;position:absolute;width:25.1%}.katex .brace-center{left:25%;overflow:hidden;position:absolute;width:50%}.katex .brace-right{overflow:hidden;position:absolute;right:0;width:25.1%}.katex .x-arrow-pad{padding:0 .5em}.katex .cd-arrow-pad{padding:0 .55556em 0 .27778em}.katex .mover,.katex .munder,.katex .x-arrow{text-align:center}.katex .boxpad{padding:0 .3em}.katex .fbox,.katex .fcolorbox{border:.04em solid;box-sizing:border-box}.katex .cancel-pad{padding:0 .2em}.katex .cancel-lap{margin-left:-.2em;margin-right:-.2em}.katex .sout{border-bottom-style:solid;border-bottom-width:.08em}.katex .angl{border-right:.049em solid;border-top:.049em solid;box-sizing:border-box;margin-right:.03889em}.katex .anglpad{padding:0 .03889em}.katex .eqn-num:before{content:"(" counter(katexEqnNo) ")";counter-increment:katexEqnNo}.katex .mml-eqn-num:before{content:"(" counter(mmlEqnNo) ")";counter-increment:mmlEqnNo}.katex .mtr-glue{width:50%}.katex .cd-vert-arrow{display:inline-block;position:relative}.katex .cd-label-left{display:inline-block;position:absolute;right:calc(50% + .3em);text-align:left}.katex .cd-label-right{display:inline-block;left:calc(50% + .3em);position:absolute;text-align:right}.katex-display{display:block;margin:1em 0;text-align:center}.katex-display>.katex{display:block;text-align:center;white-space:nowrap}.katex-display>.katex>.katex-html{display:block;position:relative}.katex-display>.katex>.katex-html>.tag{position:absolute;right:0}.katex-display.leqno>.katex>.katex-html>.tag{left:0;right:auto}.katex-display.fleqn>.katex{padding-left:2em;text-align:left}body{counter-reset:katexEqnNo mmlEqnNo} diff --git a/docs/src/starlight.custom.css b/docs/src/starlight.custom.css new file mode 100644 index 000000000..ad513f928 --- /dev/null +++ b/docs/src/starlight.custom.css @@ -0,0 +1,97 @@ +/* + Color palettes are generated via: + https://starlight.astro.build/guides/css-and-tailwind/#color-theme-editor +*/ + +/* Dark mode colors. */ +:root { + --sl-color-accent-low: #00234c; + --sl-color-accent: #0067c9; + --sl-color-accent-high: #a4ccff; + --sl-color-white: #ffffff; + --sl-color-gray-1: #eceef2; + --sl-color-gray-2: #c0c2c7; + --sl-color-gray-3: #888b96; + --sl-color-gray-4: #545861; + --sl-color-gray-5: #353841; + --sl-color-gray-6: #24272f; + --sl-color-black: #17181c; +} + +/* Light mode colors. */ +:root[data-theme='light'] { + --sl-color-accent-low: #bddaff; + --sl-color-accent: #0069cd; + --sl-color-accent-high: #003166; + --sl-color-white: #17181c; + --sl-color-gray-1: #24272f; + --sl-color-gray-2: #353841; + --sl-color-gray-3: #545861; + --sl-color-gray-4: #888b96; + --sl-color-gray-5: #c0c2c7; + --sl-color-gray-6: #eceef2; + --sl-color-gray-7: #f5f6f8; + --sl-color-black: #ffffff; +} + +/* Clip the right side of the view */ +.fifty { + clip-path: inset(0 0 0 50%); +} + +/* Add bigger margin between steps. */ +.sl-steps>li+li { + margin-top: 1.25rem; +} + +/* Add an autolink '#' to headings */ + +h1 .autolink-header, +h5 .autolink-header, +h6 .autolink-header { + display: none; +} + +h2:hover .autolink-header, +h3:hover .autolink-header, +h4:hover .autolink-header { + opacity: 1; +} + +.autolink-header { + opacity: 0; + transition: opacity 0.1s ease-in-out; + margin-left: 4px; + text-decoration: none; +} + +.autolink-header::after { + content: '#'; + color: #7d8080; + padding-left: 0.25rem; + padding-right: 0.25rem; +} + +:root[data-theme~='light'] .autolink-header::after { + color: #acaeae; +} + +/* # */ + +/* Disable bold fonts on nested group labels */ +ul ul div.group-label > span.large { + font-size: var(--sl-text-sm); + font-weight: inherit; + color: inherit; +} + +/* Add a sidebar separator */ +.sidebar-separator { + margin-top: 1rem; + font-weight: 600; + pointer-events: none; +} + +/* CSS classes to modify / target: */ +/* .sidebar-content .group-label */ +/* */ diff --git a/docs/tsconfig.json b/docs/tsconfig.json new file mode 100644 index 000000000..77da9dd00 --- /dev/null +++ b/docs/tsconfig.json @@ -0,0 +1,3 @@ +{ + "extends": "astro/tsconfigs/strict" +} \ No newline at end of file diff --git a/docs/yarn.lock b/docs/yarn.lock new file mode 100644 index 000000000..3ef25f6f4 --- /dev/null +++ b/docs/yarn.lock @@ -0,0 +1,5410 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@ampproject/remapping@^2.2.0": + version "2.3.0" + resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.3.0.tgz#ed441b6fa600072520ce18b43d2c8cc8caecc7f4" + integrity sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw== + dependencies: + "@jridgewell/gen-mapping" "^0.3.5" + "@jridgewell/trace-mapping" "^0.3.24" + +"@astrojs/check@^0.9.3": + version "0.9.3" + resolved "https://registry.yarnpkg.com/@astrojs/check/-/check-0.9.3.tgz#e8b1ce5ccc5714c8861b55201a229d372fff609c" + integrity sha512-I6Dz45bMI5YRbp4yK2LKWsHH3/kkHRGdPGruGkLap6pqxhdcNh7oCgN04Ac+haDfc9ow5BYPGPmEhkwef15GQQ== + dependencies: + "@astrojs/language-server" "^2.14.1" + chokidar "^3.5.3" + fast-glob "^3.3.1" + kleur "^4.1.5" + yargs "^17.7.2" + +"@astrojs/compiler@^2.10.3": + version "2.10.3" + resolved "https://registry.yarnpkg.com/@astrojs/compiler/-/compiler-2.10.3.tgz#852386445029f7765a70b4c1d1140e175e1d8c27" + integrity sha512-bL/O7YBxsFt55YHU021oL+xz+B/9HvGNId3F9xURN16aeqDK9juHGktdkCSXz+U4nqFACq6ZFvWomOzhV+zfPw== + +"@astrojs/internal-helpers@0.4.1": + version "0.4.1" + resolved "https://registry.yarnpkg.com/@astrojs/internal-helpers/-/internal-helpers-0.4.1.tgz#ceb5de49346dbdbfb6cba1b683c07fef7df56e1c" + integrity sha512-bMf9jFihO8YP940uD70SI/RDzIhUHJAolWVcO1v5PUivxGKvfLZTLTVVxEYzGYyPsA3ivdLNqMnL5VgmQySa+g== + +"@astrojs/language-server@^2.14.1": + version "2.14.2" + resolved "https://registry.yarnpkg.com/@astrojs/language-server/-/language-server-2.14.2.tgz#76b29ba0bb5fea7cbaa55285aa8790efc93b8863" + integrity sha512-daUJ/+/2pPF3eGG4tVdXKyw0tabUDrJKwLzU8VTuNhEHIn3VZAIES6VT3+mX0lmKcMiKM8/bjZdfY+fPfmnsMA== + dependencies: + "@astrojs/compiler" "^2.10.3" + "@astrojs/yaml2ts" "^0.2.1" + "@jridgewell/sourcemap-codec" "^1.4.15" + "@volar/kit" "~2.4.0" + "@volar/language-core" "~2.4.0" + "@volar/language-server" "~2.4.0" + "@volar/language-service" "~2.4.0" + "@volar/typescript" "~2.4.0" + fast-glob "^3.2.12" + muggle-string "^0.4.1" + volar-service-css "0.0.61" + volar-service-emmet "0.0.61" + volar-service-html "0.0.61" + volar-service-prettier "0.0.61" + volar-service-typescript "0.0.61" + volar-service-typescript-twoslash-queries "0.0.61" + volar-service-yaml "0.0.61" + vscode-html-languageservice "^5.2.0" + vscode-uri "^3.0.8" + +"@astrojs/markdown-remark@5.2.0", "@astrojs/markdown-remark@^5.2.0": + version "5.2.0" + resolved "https://registry.yarnpkg.com/@astrojs/markdown-remark/-/markdown-remark-5.2.0.tgz#15955e22b74256ed0f1c2b6e98ebcc277b1abe19" + integrity sha512-vWGM24KZXz11jR3JO+oqYU3T2qpuOi4uGivJ9SQLCAI01+vEkHC60YJMRvHPc+hwd60F7euNs1PeOEixIIiNQw== + dependencies: + "@astrojs/prism" "3.1.0" + github-slugger "^2.0.0" + hast-util-from-html "^2.0.1" + hast-util-to-text "^4.0.2" + import-meta-resolve "^4.1.0" + mdast-util-definitions "^6.0.0" + rehype-raw "^7.0.0" + rehype-stringify "^10.0.0" + remark-gfm "^4.0.0" + remark-parse "^11.0.0" + remark-rehype "^11.1.0" + remark-smartypants "^3.0.2" + shiki "^1.10.3" + unified "^11.0.5" + unist-util-remove-position "^5.0.0" + unist-util-visit "^5.0.0" + unist-util-visit-parents "^6.0.1" + vfile "^6.0.2" + +"@astrojs/mdx@^3.1.3": + version "3.1.7" + resolved "https://registry.yarnpkg.com/@astrojs/mdx/-/mdx-3.1.7.tgz#f93ca0b21696c900a89573c48e4e6ba3923721c8" + integrity sha512-8lGdCt+S0TrZgQpbcP3fQJc4cTeacAirtz9TpAMtHCWrQGW8slKt3WG4/0N+bhZgYRC4h5AT5drzFz+y3wvmsg== + dependencies: + "@astrojs/markdown-remark" "5.2.0" + "@mdx-js/mdx" "^3.0.1" + acorn "^8.12.1" + es-module-lexer "^1.5.4" + estree-util-visit "^2.0.0" + gray-matter "^4.0.3" + hast-util-to-html "^9.0.2" + kleur "^4.1.5" + rehype-raw "^7.0.0" + remark-gfm "^4.0.0" + remark-smartypants "^3.0.2" + source-map "^0.7.4" + unist-util-visit "^5.0.0" + vfile "^6.0.3" + +"@astrojs/prism@3.1.0": + version "3.1.0" + resolved "https://registry.yarnpkg.com/@astrojs/prism/-/prism-3.1.0.tgz#1b70432e0b16fafda191ce780c2820822a55bc46" + integrity sha512-Z9IYjuXSArkAUx3N6xj6+Bnvx8OdUSHA8YoOgyepp3+zJmtVYJIl/I18GozdJVW1p5u/CNpl3Km7/gwTJK85cw== + dependencies: + prismjs "^1.29.0" + +"@astrojs/sitemap@^3.1.6": + version "3.1.6" + resolved "https://registry.yarnpkg.com/@astrojs/sitemap/-/sitemap-3.1.6.tgz#32bba41b6512ee97ea42633593046b1a22658260" + integrity sha512-1Qp2NvAzVImqA6y+LubKi1DVhve/hXXgFvB0szxiipzh7BvtuKe4oJJ9dXSqaubaTkt4nMa6dv6RCCAYeB6xaQ== + dependencies: + sitemap "^7.1.2" + stream-replace-string "^2.0.0" + zod "^3.23.8" + +"@astrojs/starlight@^0.28.2": + version "0.28.2" + resolved "https://registry.yarnpkg.com/@astrojs/starlight/-/starlight-0.28.2.tgz#108f847ed533be6024a83389b0e94f6b236fe6f0" + integrity sha512-Q1/Ujl2EzWX71qwqdt/0KP3wOyX6Rvyzcep/zD3hRCtw/Vi2TReh4Q2wLwz7mnbuYU9H7YvBKYknbkmjC+K/0w== + dependencies: + "@astrojs/mdx" "^3.1.3" + "@astrojs/sitemap" "^3.1.6" + "@pagefind/default-ui" "^1.0.3" + "@types/hast" "^3.0.4" + "@types/mdast" "^4.0.4" + astro-expressive-code "^0.35.6" + bcp-47 "^2.1.0" + hast-util-from-html "^2.0.1" + hast-util-select "^6.0.2" + hast-util-to-string "^3.0.0" + hastscript "^9.0.0" + i18next "^23.11.5" + mdast-util-directive "^3.0.0" + mdast-util-to-markdown "^2.1.0" + mdast-util-to-string "^4.0.0" + pagefind "^1.0.3" + rehype "^13.0.1" + rehype-format "^5.0.0" + remark-directive "^3.0.0" + unified "^11.0.5" + unist-util-visit "^5.0.0" + vfile "^6.0.2" + +"@astrojs/telemetry@3.1.0": + version "3.1.0" + resolved "https://registry.yarnpkg.com/@astrojs/telemetry/-/telemetry-3.1.0.tgz#1038bea408a0f8cf363fb939afeefed751f1f86f" + integrity sha512-/ca/+D8MIKEC8/A9cSaPUqQNZm+Es/ZinRv0ZAzvu2ios7POQSsVD+VOj7/hypWNsNM3T7RpfgNq7H2TU1KEHA== + dependencies: + ci-info "^4.0.0" + debug "^4.3.4" + dlv "^1.1.3" + dset "^3.1.3" + is-docker "^3.0.0" + is-wsl "^3.0.0" + which-pm-runs "^1.1.0" + +"@astrojs/yaml2ts@^0.2.1": + version "0.2.1" + resolved "https://registry.yarnpkg.com/@astrojs/yaml2ts/-/yaml2ts-0.2.1.tgz#dd77834ea5c902e68dec1391a5a30718b0ab3f0b" + integrity sha512-CBaNwDQJz20E5WxzQh4thLVfhB3JEEGz72wRA+oJp6fQR37QLAqXZJU0mHC+yqMOQ6oj0GfRPJrz6hjf+zm6zA== + dependencies: + yaml "^2.5.0" + +"@babel/code-frame@^7.24.7": + version "7.24.7" + resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.24.7.tgz#882fd9e09e8ee324e496bd040401c6f046ef4465" + integrity sha512-BcYH1CVJBO9tvyIZ2jVeXgSIMvGZ2FDRvDdOIVQyuklNKSsx+eppDEBq/g47Ayw+RqNFE+URvOShmf+f/qwAlA== + dependencies: + "@babel/highlight" "^7.24.7" + picocolors "^1.0.0" + +"@babel/compat-data@^7.25.2": + version "7.25.4" + resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.25.4.tgz#7d2a80ce229890edcf4cc259d4d696cb4dae2fcb" + integrity sha512-+LGRog6RAsCJrrrg/IO6LGmpphNe5DiK30dGjCoxxeGv49B10/3XYGxPsAwrDlMFcFEvdAUavDT8r9k/hSyQqQ== + +"@babel/core@^7.25.2": + version "7.25.2" + resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.25.2.tgz#ed8eec275118d7613e77a352894cd12ded8eba77" + integrity sha512-BBt3opiCOxUr9euZ5/ro/Xv8/V7yJ5bjYMqG/C1YAo8MIKAnumZalCN+msbci3Pigy4lIQfPUpfMM27HMGaYEA== + dependencies: + "@ampproject/remapping" "^2.2.0" + "@babel/code-frame" "^7.24.7" + "@babel/generator" "^7.25.0" + "@babel/helper-compilation-targets" "^7.25.2" + "@babel/helper-module-transforms" "^7.25.2" + "@babel/helpers" "^7.25.0" + "@babel/parser" "^7.25.0" + "@babel/template" "^7.25.0" + "@babel/traverse" "^7.25.2" + "@babel/types" "^7.25.2" + convert-source-map "^2.0.0" + debug "^4.1.0" + gensync "^1.0.0-beta.2" + json5 "^2.2.3" + semver "^6.3.1" + +"@babel/generator@^7.25.0", "@babel/generator@^7.25.6": + version "7.25.6" + resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.25.6.tgz#0df1ad8cb32fe4d2b01d8bf437f153d19342a87c" + integrity sha512-VPC82gr1seXOpkjAAKoLhP50vx4vGNlF4msF64dSFq1P8RfB+QAuJWGHPXXPc8QyfVWwwB/TNNU4+ayZmHNbZw== + dependencies: + "@babel/types" "^7.25.6" + "@jridgewell/gen-mapping" "^0.3.5" + "@jridgewell/trace-mapping" "^0.3.25" + jsesc "^2.5.1" + +"@babel/helper-annotate-as-pure@^7.24.7": + version "7.24.7" + resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.24.7.tgz#5373c7bc8366b12a033b4be1ac13a206c6656aab" + integrity sha512-BaDeOonYvhdKw+JoMVkAixAAJzG2jVPIwWoKBPdYuY9b452e2rPuI9QPYh3KpofZ3pW2akOmwZLOiOsHMiqRAg== + dependencies: + "@babel/types" "^7.24.7" + +"@babel/helper-compilation-targets@^7.25.2": + version "7.25.2" + resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.25.2.tgz#e1d9410a90974a3a5a66e84ff55ef62e3c02d06c" + integrity sha512-U2U5LsSaZ7TAt3cfaymQ8WHh0pxvdHoEk6HVpaexxixjyEquMh0L0YNJNM6CTGKMXV1iksi0iZkGw4AcFkPaaw== + dependencies: + "@babel/compat-data" "^7.25.2" + "@babel/helper-validator-option" "^7.24.8" + browserslist "^4.23.1" + lru-cache "^5.1.1" + semver "^6.3.1" + +"@babel/helper-module-imports@^7.24.7": + version "7.24.7" + resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.24.7.tgz#f2f980392de5b84c3328fc71d38bd81bbb83042b" + integrity sha512-8AyH3C+74cgCVVXow/myrynrAGv+nTVg5vKu2nZph9x7RcRwzmh0VFallJuFTZ9mx6u4eSdXZfcOzSqTUm0HCA== + dependencies: + "@babel/traverse" "^7.24.7" + "@babel/types" "^7.24.7" + +"@babel/helper-module-transforms@^7.25.2": + version "7.25.2" + resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.25.2.tgz#ee713c29768100f2776edf04d4eb23b8d27a66e6" + integrity sha512-BjyRAbix6j/wv83ftcVJmBt72QtHI56C7JXZoG2xATiLpmoC7dpd8WnkikExHDVPpi/3qCmO6WY1EaXOluiecQ== + dependencies: + "@babel/helper-module-imports" "^7.24.7" + "@babel/helper-simple-access" "^7.24.7" + "@babel/helper-validator-identifier" "^7.24.7" + "@babel/traverse" "^7.25.2" + +"@babel/helper-plugin-utils@^7.24.7", "@babel/helper-plugin-utils@^7.24.8": + version "7.24.8" + resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.24.8.tgz#94ee67e8ec0e5d44ea7baeb51e571bd26af07878" + integrity sha512-FFWx5142D8h2Mgr/iPVGH5G7w6jDn4jUSpZTyDnQO0Yn7Ks2Kuz6Pci8H6MPCoUJegd/UZQ3tAvfLCxQSnWWwg== + +"@babel/helper-simple-access@^7.24.7": + version "7.24.7" + resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.24.7.tgz#bcade8da3aec8ed16b9c4953b74e506b51b5edb3" + integrity sha512-zBAIvbCMh5Ts+b86r/CjU+4XGYIs+R1j951gxI3KmmxBMhCg4oQMsv6ZXQ64XOm/cvzfU1FmoCyt6+owc5QMYg== + dependencies: + "@babel/traverse" "^7.24.7" + "@babel/types" "^7.24.7" + +"@babel/helper-string-parser@^7.24.8": + version "7.24.8" + resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.24.8.tgz#5b3329c9a58803d5df425e5785865881a81ca48d" + integrity sha512-pO9KhhRcuUyGnJWwyEgnRJTSIZHiT+vMD0kPeD+so0l7mxkMT19g3pjY9GTnHySck/hDzq+dtW/4VgnMkippsQ== + +"@babel/helper-validator-identifier@^7.24.7": + version "7.24.7" + resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.24.7.tgz#75b889cfaf9e35c2aaf42cf0d72c8e91719251db" + integrity sha512-rR+PBcQ1SMQDDyF6X0wxtG8QyLCgUB0eRAGguqRLfkCA87l7yAP7ehq8SNj96OOGTO8OBV70KhuFYcIkHXOg0w== + +"@babel/helper-validator-option@^7.24.8": + version "7.24.8" + resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.24.8.tgz#3725cdeea8b480e86d34df15304806a06975e33d" + integrity sha512-xb8t9tD1MHLungh/AIoWYN+gVHaB9kwlu8gffXGSt3FFEIT7RjS+xWbc2vUD1UTZdIpKj/ab3rdqJ7ufngyi2Q== + +"@babel/helpers@^7.25.0": + version "7.25.6" + resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.25.6.tgz#57ee60141829ba2e102f30711ffe3afab357cc60" + integrity sha512-Xg0tn4HcfTijTwfDwYlvVCl43V6h4KyVVX2aEm4qdO/PC6L2YvzLHFdmxhoeSA3eslcE6+ZVXHgWwopXYLNq4Q== + dependencies: + "@babel/template" "^7.25.0" + "@babel/types" "^7.25.6" + +"@babel/highlight@^7.24.7": + version "7.24.7" + resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.24.7.tgz#a05ab1df134b286558aae0ed41e6c5f731bf409d" + integrity sha512-EStJpq4OuY8xYfhGVXngigBJRWxftKX9ksiGDnmlY3o7B/V7KIAc9X4oiK87uPJSc/vs5L869bem5fhZa8caZw== + dependencies: + "@babel/helper-validator-identifier" "^7.24.7" + chalk "^2.4.2" + js-tokens "^4.0.0" + picocolors "^1.0.0" + +"@babel/parser@^7.1.0", "@babel/parser@^7.20.7", "@babel/parser@^7.25.0", "@babel/parser@^7.25.4", "@babel/parser@^7.25.6": + version "7.25.6" + resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.25.6.tgz#85660c5ef388cbbf6e3d2a694ee97a38f18afe2f" + integrity sha512-trGdfBdbD0l1ZPmcJ83eNxB9rbEax4ALFTF7fN386TMYbeCQbyme5cOEXQhbGXKebwGaB/J52w1mrklMcbgy6Q== + dependencies: + "@babel/types" "^7.25.6" + +"@babel/plugin-syntax-jsx@^7.24.7": + version "7.24.7" + resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.24.7.tgz#39a1fa4a7e3d3d7f34e2acc6be585b718d30e02d" + integrity sha512-6ddciUPe/mpMnOKv/U+RSd2vvVy+Yw/JfBB0ZHYjEZt9NLHmCUylNYlsbqCCS1Bffjlb0fCwC9Vqz+sBz6PsiQ== + dependencies: + "@babel/helper-plugin-utils" "^7.24.7" + +"@babel/plugin-transform-react-jsx@^7.25.2": + version "7.25.2" + resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.25.2.tgz#e37e8ebfa77e9f0b16ba07fadcb6adb47412227a" + integrity sha512-KQsqEAVBpU82NM/B/N9j9WOdphom1SZH3R+2V7INrQUH+V9EBFwZsEJl8eBIVeQE62FxJCc70jzEZwqU7RcVqA== + dependencies: + "@babel/helper-annotate-as-pure" "^7.24.7" + "@babel/helper-module-imports" "^7.24.7" + "@babel/helper-plugin-utils" "^7.24.8" + "@babel/plugin-syntax-jsx" "^7.24.7" + "@babel/types" "^7.25.2" + +"@babel/runtime@^7.23.2": + version "7.25.6" + resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.25.6.tgz#9afc3289f7184d8d7f98b099884c26317b9264d2" + integrity sha512-VBj9MYyDb9tuLq7yzqjgzt6Q+IBQLrGZfdjOekyEirZPHxXWoTSGUTMrpsfi58Up73d13NfYLv8HT9vmznjzhQ== + dependencies: + regenerator-runtime "^0.14.0" + +"@babel/template@^7.25.0": + version "7.25.0" + resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.25.0.tgz#e733dc3134b4fede528c15bc95e89cb98c52592a" + integrity sha512-aOOgh1/5XzKvg1jvVz7AVrx2piJ2XBi227DHmbY6y+bM9H2FlN+IfecYu4Xl0cNiiVejlsCri89LUsbj8vJD9Q== + dependencies: + "@babel/code-frame" "^7.24.7" + "@babel/parser" "^7.25.0" + "@babel/types" "^7.25.0" + +"@babel/traverse@^7.24.7", "@babel/traverse@^7.25.2": + version "7.25.6" + resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.25.6.tgz#04fad980e444f182ecf1520504941940a90fea41" + integrity sha512-9Vrcx5ZW6UwK5tvqsj0nGpp/XzqthkT0dqIc9g1AdtygFToNtTF67XzYS//dm+SAK9cp3B9R4ZO/46p63SCjlQ== + dependencies: + "@babel/code-frame" "^7.24.7" + "@babel/generator" "^7.25.6" + "@babel/parser" "^7.25.6" + "@babel/template" "^7.25.0" + "@babel/types" "^7.25.6" + debug "^4.3.1" + globals "^11.1.0" + +"@babel/types@^7.0.0", "@babel/types@^7.20.7", "@babel/types@^7.24.7", "@babel/types@^7.25.0", "@babel/types@^7.25.2", "@babel/types@^7.25.4", "@babel/types@^7.25.6": + version "7.25.6" + resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.25.6.tgz#893942ddb858f32ae7a004ec9d3a76b3463ef8e6" + integrity sha512-/l42B1qxpG6RdfYf343Uw1vmDjeNhneUXtzhojE7pDgfpEypmRhI6j1kr17XCVv4Cgl9HdAiQY2x0GwKm7rWCw== + dependencies: + "@babel/helper-string-parser" "^7.24.8" + "@babel/helper-validator-identifier" "^7.24.7" + to-fast-properties "^2.0.0" + +"@cspell/cspell-bundled-dicts@8.14.4": + version "8.14.4" + resolved "https://registry.yarnpkg.com/@cspell/cspell-bundled-dicts/-/cspell-bundled-dicts-8.14.4.tgz#61e116fb3c505d4ebf2f842f24ea1e39bc47d469" + integrity sha512-JHZOpCJzN6fPBapBOvoeMxZbr0ZA11ZAkwcqM4w0lKoacbi6TwK8GIYf66hHvwLmMeav75TNXWE6aPTvBLMMqA== + dependencies: + "@cspell/dict-ada" "^4.0.2" + "@cspell/dict-aws" "^4.0.4" + "@cspell/dict-bash" "^4.1.4" + "@cspell/dict-companies" "^3.1.4" + "@cspell/dict-cpp" "^5.1.16" + "@cspell/dict-cryptocurrencies" "^5.0.0" + "@cspell/dict-csharp" "^4.0.2" + "@cspell/dict-css" "^4.0.13" + "@cspell/dict-dart" "^2.2.1" + "@cspell/dict-django" "^4.1.0" + "@cspell/dict-docker" "^1.1.7" + "@cspell/dict-dotnet" "^5.0.5" + "@cspell/dict-elixir" "^4.0.3" + "@cspell/dict-en-common-misspellings" "^2.0.4" + "@cspell/dict-en-gb" "1.1.33" + "@cspell/dict-en_us" "^4.3.23" + "@cspell/dict-filetypes" "^3.0.4" + "@cspell/dict-flutter" "^1.0.0" + "@cspell/dict-fonts" "^4.0.0" + "@cspell/dict-fsharp" "^1.0.1" + "@cspell/dict-fullstack" "^3.2.0" + "@cspell/dict-gaming-terms" "^1.0.5" + "@cspell/dict-git" "^3.0.0" + "@cspell/dict-golang" "^6.0.12" + "@cspell/dict-google" "^1.0.1" + "@cspell/dict-haskell" "^4.0.1" + "@cspell/dict-html" "^4.0.5" + "@cspell/dict-html-symbol-entities" "^4.0.0" + "@cspell/dict-java" "^5.0.7" + "@cspell/dict-julia" "^1.0.1" + "@cspell/dict-k8s" "^1.0.6" + "@cspell/dict-latex" "^4.0.0" + "@cspell/dict-lorem-ipsum" "^4.0.0" + "@cspell/dict-lua" "^4.0.3" + "@cspell/dict-makefile" "^1.0.0" + "@cspell/dict-monkeyc" "^1.0.6" + "@cspell/dict-node" "^5.0.1" + "@cspell/dict-npm" "^5.1.4" + "@cspell/dict-php" "^4.0.10" + "@cspell/dict-powershell" "^5.0.8" + "@cspell/dict-public-licenses" "^2.0.8" + "@cspell/dict-python" "^4.2.6" + "@cspell/dict-r" "^2.0.1" + "@cspell/dict-ruby" "^5.0.3" + "@cspell/dict-rust" "^4.0.5" + "@cspell/dict-scala" "^5.0.3" + "@cspell/dict-software-terms" "^4.1.3" + "@cspell/dict-sql" "^2.1.5" + "@cspell/dict-svelte" "^1.0.2" + "@cspell/dict-swift" "^2.0.1" + "@cspell/dict-terraform" "^1.0.1" + "@cspell/dict-typescript" "^3.1.6" + "@cspell/dict-vue" "^3.0.0" + +"@cspell/cspell-json-reporter@8.14.4": + version "8.14.4" + resolved "https://registry.yarnpkg.com/@cspell/cspell-json-reporter/-/cspell-json-reporter-8.14.4.tgz#4646c1963b9b02fea3faae3c5ee04fb6dda8548e" + integrity sha512-gJ6tQbGCNLyHS2iIimMg77as5MMAFv3sxU7W6tjLlZp8htiNZS7fS976g24WbT/hscsTT9Dd0sNHkpo8K3nvVw== + dependencies: + "@cspell/cspell-types" "8.14.4" + +"@cspell/cspell-pipe@8.14.4": + version "8.14.4" + resolved "https://registry.yarnpkg.com/@cspell/cspell-pipe/-/cspell-pipe-8.14.4.tgz#5e81509d7c2763ac0e8c09b7989fe95e36fe0a05" + integrity sha512-CLLdouqfrQ4rqdQdPu0Oo+HHCU/oLYoEsK1nNPb28cZTFxnn0cuSPKB6AMPBJmMwdfJ6fMD0BCKNbEe1UNLHcw== + +"@cspell/cspell-resolver@8.14.4": + version "8.14.4" + resolved "https://registry.yarnpkg.com/@cspell/cspell-resolver/-/cspell-resolver-8.14.4.tgz#839258970996c8262b290f6e8fbbac27d43fb0b8" + integrity sha512-s3uZyymJ04yn8+zlTp7Pt1WRSlAel6XVo+iZRxls3LSvIP819KK64DoyjCD2Uon0Vg9P/K7aAPt8GcxDcnJtgA== + dependencies: + global-directory "^4.0.1" + +"@cspell/cspell-service-bus@8.14.4": + version "8.14.4" + resolved "https://registry.yarnpkg.com/@cspell/cspell-service-bus/-/cspell-service-bus-8.14.4.tgz#3c081578c7a369e4a737311e8ee31e709a48abb8" + integrity sha512-i3UG+ep63akNsDXZrtGgICNF3MLBHtvKe/VOIH6+L+NYaAaVHqqQvOY9MdUwt1HXh8ElzfwfoRp36wc5aAvt6g== + +"@cspell/cspell-types@8.14.4": + version "8.14.4" + resolved "https://registry.yarnpkg.com/@cspell/cspell-types/-/cspell-types-8.14.4.tgz#93ceff0bcefe75c259ae3475961f580f3de36e79" + integrity sha512-VXwikqdHgjOVperVVCn2DOe8W3rPIswwZtMHfRYnagpzZo/TOntIjkXPJSfTtl/cFyx5DnCBsDH8ytKGlMeHkw== + +"@cspell/dict-ada@^4.0.2": + version "4.0.2" + resolved "https://registry.yarnpkg.com/@cspell/dict-ada/-/dict-ada-4.0.2.tgz#8da2216660aeb831a0d9055399a364a01db5805a" + integrity sha512-0kENOWQeHjUlfyId/aCM/mKXtkEgV0Zu2RhUXCBr4hHo9F9vph+Uu8Ww2b0i5a4ZixoIkudGA+eJvyxrG1jUpA== + +"@cspell/dict-aws@^4.0.4": + version "4.0.4" + resolved "https://registry.yarnpkg.com/@cspell/dict-aws/-/dict-aws-4.0.4.tgz#638a38df18c93d5cb74607b24ab4e1498825d565" + integrity sha512-6AWI/Kkf+RcX/J81VX8+GKLeTgHWEr/OMhGk3dHQzWK66RaqDJCGDqi7494ghZKcBB7dGa3U5jcKw2FZHL/u3w== + +"@cspell/dict-bash@^4.1.4": + version "4.1.4" + resolved "https://registry.yarnpkg.com/@cspell/dict-bash/-/dict-bash-4.1.4.tgz#a7942df189d3cc5ebced5b877d64ddbb24301137" + integrity sha512-W/AHoQcJYn3Vn/tUiXX2+6D/bhfzdDshwcbQWv9TdiNlXP9P6UJjDKWbxyA5ogJCsR2D0X9Kx11oV8E58siGKQ== + +"@cspell/dict-companies@^3.1.4": + version "3.1.4" + resolved "https://registry.yarnpkg.com/@cspell/dict-companies/-/dict-companies-3.1.4.tgz#2e7094416432b8547ec335683f5aac9a49dce47e" + integrity sha512-y9e0amzEK36EiiKx3VAA+SHQJPpf2Qv5cCt5eTUSggpTkiFkCh6gRKQ97rVlrKh5GJrqinDwYIJtTsxuh2vy2Q== + +"@cspell/dict-cpp@^5.1.16": + version "5.1.16" + resolved "https://registry.yarnpkg.com/@cspell/dict-cpp/-/dict-cpp-5.1.16.tgz#e6557d5b916ebff02045b60f7016749e085921b0" + integrity sha512-32fU5RkuOM55IRcxjByiSoKbjr+C4danDfYjHaQNRWdvjzJzci3fLDGA2wTXiclkgDODxGiV8LCTUwCz+3TNWA== + +"@cspell/dict-cryptocurrencies@^5.0.0": + version "5.0.0" + resolved "https://registry.yarnpkg.com/@cspell/dict-cryptocurrencies/-/dict-cryptocurrencies-5.0.0.tgz#19fbc7bdbec76ce64daf7d53a6d0f3cfff7d0038" + integrity sha512-Z4ARIw5+bvmShL+4ZrhDzGhnc9znaAGHOEMaB/GURdS/jdoreEDY34wdN0NtdLHDO5KO7GduZnZyqGdRoiSmYA== + +"@cspell/dict-csharp@^4.0.2": + version "4.0.2" + resolved "https://registry.yarnpkg.com/@cspell/dict-csharp/-/dict-csharp-4.0.2.tgz#e55659dbe594e744d86b1baf0f3397fe57b1e283" + integrity sha512-1JMofhLK+4p4KairF75D3A924m5ERMgd1GvzhwK2geuYgd2ZKuGW72gvXpIV7aGf52E3Uu1kDXxxGAiZ5uVG7g== + +"@cspell/dict-css@^4.0.13": + version "4.0.13" + resolved "https://registry.yarnpkg.com/@cspell/dict-css/-/dict-css-4.0.13.tgz#b95310ba67694d25bcb055786dde65e091621d14" + integrity sha512-WfOQkqlAJTo8eIQeztaH0N0P+iF5hsJVKFuhy4jmARPISy8Efcv8QXk2/IVbmjJH0/ZV7dKRdnY5JFVXuVz37g== + +"@cspell/dict-dart@^2.2.1": + version "2.2.1" + resolved "https://registry.yarnpkg.com/@cspell/dict-dart/-/dict-dart-2.2.1.tgz#d5ef7632240cb19c8892e66ba5ed1089ab8e46a3" + integrity sha512-yriKm7QkoPx3JPSSOcw6iX9gOb2N50bOo/wqWviqPYbhpMRh9Xiv6dkUy3+ot+21GuShZazO8X6U5+Vw67XEwg== + +"@cspell/dict-data-science@^2.0.1": + version "2.0.1" + resolved "https://registry.yarnpkg.com/@cspell/dict-data-science/-/dict-data-science-2.0.1.tgz#ef8040821567786d76c6153ac3e4bc265ca65b59" + integrity sha512-xeutkzK0eBe+LFXOFU2kJeAYO6IuFUc1g7iRLr7HeCmlC4rsdGclwGHh61KmttL3+YHQytYStxaRBdGAXWC8Lw== + +"@cspell/dict-django@^4.1.0": + version "4.1.0" + resolved "https://registry.yarnpkg.com/@cspell/dict-django/-/dict-django-4.1.0.tgz#2d4b765daf3c83e733ef3e06887ea34403a4de7a" + integrity sha512-bKJ4gPyrf+1c78Z0Oc4trEB9MuhcB+Yg+uTTWsvhY6O2ncFYbB/LbEZfqhfmmuK/XJJixXfI1laF2zicyf+l0w== + +"@cspell/dict-docker@^1.1.7": + version "1.1.7" + resolved "https://registry.yarnpkg.com/@cspell/dict-docker/-/dict-docker-1.1.7.tgz#bcf933283fbdfef19c71a642e7e8c38baf9014f2" + integrity sha512-XlXHAr822euV36GGsl2J1CkBIVg3fZ6879ZOg5dxTIssuhUOCiV2BuzKZmt6aIFmcdPmR14+9i9Xq+3zuxeX0A== + +"@cspell/dict-dotnet@^5.0.5": + version "5.0.5" + resolved "https://registry.yarnpkg.com/@cspell/dict-dotnet/-/dict-dotnet-5.0.5.tgz#0f614ef6fa052e7598a6fe20770a1e5bb19f0de1" + integrity sha512-gjg0L97ee146wX47dnA698cHm85e7EOpf9mVrJD8DmEaqoo/k1oPy2g7c7LgKxK9XnqwoXxhLNnngPrwXOoEtQ== + +"@cspell/dict-elixir@^4.0.3": + version "4.0.3" + resolved "https://registry.yarnpkg.com/@cspell/dict-elixir/-/dict-elixir-4.0.3.tgz#57c25843e46cf3463f97da72d9ef8e37c818296f" + integrity sha512-g+uKLWvOp9IEZvrIvBPTr/oaO6619uH/wyqypqvwpmnmpjcfi8+/hqZH8YNKt15oviK8k4CkINIqNhyndG9d9Q== + +"@cspell/dict-en-common-misspellings@^2.0.4": + version "2.0.4" + resolved "https://registry.yarnpkg.com/@cspell/dict-en-common-misspellings/-/dict-en-common-misspellings-2.0.4.tgz#725c5b2c83faff71fcd2183dd04a154c78eed674" + integrity sha512-lvOiRjV/FG4pAGZL3PN2GCVHSTCE92cwhfLGGkOsQtxSmef6WCHfHwp9auafkBlX0yFQSKDfq6/TlpQbjbJBtQ== + +"@cspell/dict-en-gb@1.1.33": + version "1.1.33" + resolved "https://registry.yarnpkg.com/@cspell/dict-en-gb/-/dict-en-gb-1.1.33.tgz#7f1fd90fc364a5cb77111b5438fc9fcf9cc6da0e" + integrity sha512-tKSSUf9BJEV+GJQAYGw5e+ouhEe2ZXE620S7BLKe3ZmpnjlNG9JqlnaBhkIMxKnNFkLY2BP/EARzw31AZnOv4g== + +"@cspell/dict-en_us@^4.3.23": + version "4.3.23" + resolved "https://registry.yarnpkg.com/@cspell/dict-en_us/-/dict-en_us-4.3.23.tgz#3362b75a5051405816728ea1bb5ce997582ed383" + integrity sha512-l0SoEQBsi3zDSl3OuL4/apBkxjuj4hLIg/oy6+gZ7LWh03rKdF6VNtSZNXWAmMY+pmb1cGA3ouleTiJIglbsIg== + +"@cspell/dict-filetypes@^3.0.4": + version "3.0.4" + resolved "https://registry.yarnpkg.com/@cspell/dict-filetypes/-/dict-filetypes-3.0.4.tgz#aca71c7bb8c8805b54f382d98ded5ec75ebc1e36" + integrity sha512-IBi8eIVdykoGgIv5wQhOURi5lmCNJq0we6DvqKoPQJHthXbgsuO1qrHSiUVydMiQl/XvcnUWTMeAlVUlUClnVg== + +"@cspell/dict-flutter@^1.0.0": + version "1.0.0" + resolved "https://registry.yarnpkg.com/@cspell/dict-flutter/-/dict-flutter-1.0.0.tgz#9179aeb5e7544c061ffa3e5080a4c015f88efee3" + integrity sha512-W7k1VIc4KeV8BjEBxpA3cqpzbDWjfb7oXkEb0LecBCBp5Z7kcfnjT1YVotTx/U9PGyAOBhDaEdgZACVGNQhayw== + +"@cspell/dict-fonts@^4.0.0": + version "4.0.0" + resolved "https://registry.yarnpkg.com/@cspell/dict-fonts/-/dict-fonts-4.0.0.tgz#9bc8beb2a7b068b4fdb45cb994b36fd184316327" + integrity sha512-t9V4GeN/m517UZn63kZPUYP3OQg5f0OBLSd3Md5CU3eH1IFogSvTzHHnz4Wqqbv8NNRiBZ3HfdY/pqREZ6br3Q== + +"@cspell/dict-fsharp@^1.0.1": + version "1.0.1" + resolved "https://registry.yarnpkg.com/@cspell/dict-fsharp/-/dict-fsharp-1.0.1.tgz#d62c699550a39174f182f23c8c1330a795ab5f53" + integrity sha512-23xyPcD+j+NnqOjRHgW3IU7Li912SX9wmeefcY0QxukbAxJ/vAN4rBpjSwwYZeQPAn3fxdfdNZs03fg+UM+4yQ== + +"@cspell/dict-fullstack@^3.2.0": + version "3.2.0" + resolved "https://registry.yarnpkg.com/@cspell/dict-fullstack/-/dict-fullstack-3.2.0.tgz#16dd2bd3f03166c8f48600ef032ae1ce184c7b8e" + integrity sha512-sIGQwU6G3rLTo+nx0GKyirR5dQSFeTIzFTOrURw51ISf+jKG9a3OmvsVtc2OANfvEAOLOC9Wfd8WYhmsO8KRDQ== + +"@cspell/dict-gaming-terms@^1.0.5": + version "1.0.5" + resolved "https://registry.yarnpkg.com/@cspell/dict-gaming-terms/-/dict-gaming-terms-1.0.5.tgz#d6ca40eb34a4c99847fd58a7354cd2c651065156" + integrity sha512-C3riccZDD3d9caJQQs1+MPfrUrQ+0KHdlj9iUR1QD92FgTOF6UxoBpvHUUZ9YSezslcmpFQK4xQQ5FUGS7uWfw== + +"@cspell/dict-git@^3.0.0": + version "3.0.0" + resolved "https://registry.yarnpkg.com/@cspell/dict-git/-/dict-git-3.0.0.tgz#c275af86041a2b59a7facce37525e2af05653b95" + integrity sha512-simGS/lIiXbEaqJu9E2VPoYW1OTC2xrwPPXNXFMa2uo/50av56qOuaxDrZ5eH1LidFXwoc8HROCHYeKoNrDLSw== + +"@cspell/dict-golang@^6.0.12": + version "6.0.12" + resolved "https://registry.yarnpkg.com/@cspell/dict-golang/-/dict-golang-6.0.12.tgz#a9d4c53edfec34d06a226a9af6af0df899bd720f" + integrity sha512-LEPeoqd+4O+vceHF73S7D7+LYfrAjOvp4Dqzh4MT30ruzlQ77yHRSuYOJtrFN1GK5ntAt/ILSVOKg9sgsz1Llg== + +"@cspell/dict-google@^1.0.1": + version "1.0.1" + resolved "https://registry.yarnpkg.com/@cspell/dict-google/-/dict-google-1.0.1.tgz#34701471a616011aeaaf480d4834436b6b6b1da5" + integrity sha512-dQr4M3n95uOhtloNSgB9tYYGXGGEGEykkFyRtfcp5pFuEecYUa0BSgtlGKx9RXVtJtKgR+yFT/a5uQSlt8WjqQ== + +"@cspell/dict-haskell@^4.0.1": + version "4.0.1" + resolved "https://registry.yarnpkg.com/@cspell/dict-haskell/-/dict-haskell-4.0.1.tgz#e9fca7c452411ff11926e23ffed2b50bb9b95e47" + integrity sha512-uRrl65mGrOmwT7NxspB4xKXFUenNC7IikmpRZW8Uzqbqcu7ZRCUfstuVH7T1rmjRgRkjcIjE4PC11luDou4wEQ== + +"@cspell/dict-html-symbol-entities@^4.0.0": + version "4.0.0" + resolved "https://registry.yarnpkg.com/@cspell/dict-html-symbol-entities/-/dict-html-symbol-entities-4.0.0.tgz#4d86ac18a4a11fdb61dfb6f5929acd768a52564f" + integrity sha512-HGRu+48ErJjoweR5IbcixxETRewrBb0uxQBd6xFGcxbEYCX8CnQFTAmKI5xNaIt2PKaZiJH3ijodGSqbKdsxhw== + +"@cspell/dict-html@^4.0.5": + version "4.0.6" + resolved "https://registry.yarnpkg.com/@cspell/dict-html/-/dict-html-4.0.6.tgz#54a753e4ea97636bbbe6b4d301744fbaac434105" + integrity sha512-cLWHfuOhE4wqwC12up6Doxo2u1xxVhX1A8zriR4CUD+osFQzUIcBK1ykNXppga+rt1WyypaJdTU2eV6OpzYrgQ== + +"@cspell/dict-java@^5.0.7": + version "5.0.7" + resolved "https://registry.yarnpkg.com/@cspell/dict-java/-/dict-java-5.0.7.tgz#c0b32d3c208b6419a5eddd010e87196976be2694" + integrity sha512-ejQ9iJXYIq7R09BScU2y5OUGrSqwcD+J5mHFOKbduuQ5s/Eh/duz45KOzykeMLI6KHPVxhBKpUPBWIsfewECpQ== + +"@cspell/dict-julia@^1.0.1": + version "1.0.1" + resolved "https://registry.yarnpkg.com/@cspell/dict-julia/-/dict-julia-1.0.1.tgz#900001417f1c4ea689530adfcc034c848458a0aa" + integrity sha512-4JsCLCRhhLMLiaHpmR7zHFjj1qOauzDI5ZzCNQS31TUMfsOo26jAKDfo0jljFAKgw5M2fEG7sKr8IlPpQAYrmQ== + +"@cspell/dict-k8s@^1.0.6": + version "1.0.6" + resolved "https://registry.yarnpkg.com/@cspell/dict-k8s/-/dict-k8s-1.0.6.tgz#d46c97136f1504b65dfb6a188005d4ac81d3f461" + integrity sha512-srhVDtwrd799uxMpsPOQqeDJY+gEocgZpoK06EFrb4GRYGhv7lXo9Fb+xQMyQytzOW9dw4DNOEck++nacDuymg== + +"@cspell/dict-latex@^4.0.0": + version "4.0.0" + resolved "https://registry.yarnpkg.com/@cspell/dict-latex/-/dict-latex-4.0.0.tgz#85054903db834ea867174795d162e2a8f0e9c51e" + integrity sha512-LPY4y6D5oI7D3d+5JMJHK/wxYTQa2lJMSNxps2JtuF8hbAnBQb3igoWEjEbIbRRH1XBM0X8dQqemnjQNCiAtxQ== + +"@cspell/dict-lorem-ipsum@^4.0.0": + version "4.0.0" + resolved "https://registry.yarnpkg.com/@cspell/dict-lorem-ipsum/-/dict-lorem-ipsum-4.0.0.tgz#2793a5dbfde474a546b0caecc40c38fdf076306e" + integrity sha512-1l3yjfNvMzZPibW8A7mQU4kTozwVZVw0AvFEdy+NcqtbxH+TvbSkNMqROOFWrkD2PjnKG0+Ea0tHI2Pi6Gchnw== + +"@cspell/dict-lua@^4.0.3": + version "4.0.3" + resolved "https://registry.yarnpkg.com/@cspell/dict-lua/-/dict-lua-4.0.3.tgz#2d23c8f7e74b4e62000678d80e7d1ebb10b003e0" + integrity sha512-lDHKjsrrbqPaea13+G9s0rtXjMO06gPXPYRjRYawbNmo4E/e3XFfVzeci3OQDQNDmf2cPOwt9Ef5lu2lDmwfJg== + +"@cspell/dict-makefile@^1.0.0": + version "1.0.0" + resolved "https://registry.yarnpkg.com/@cspell/dict-makefile/-/dict-makefile-1.0.0.tgz#5afb2910873ebbc01ab8d9c38661c4c93d0e5a40" + integrity sha512-3W9tHPcSbJa6s0bcqWo6VisEDTSN5zOtDbnPabF7rbyjRpNo0uHXHRJQF8gAbFzoTzBBhgkTmrfSiuyQm7vBUQ== + +"@cspell/dict-monkeyc@^1.0.6": + version "1.0.6" + resolved "https://registry.yarnpkg.com/@cspell/dict-monkeyc/-/dict-monkeyc-1.0.6.tgz#042d042fc34a20194c8de032130808f44b241375" + integrity sha512-oO8ZDu/FtZ55aq9Mb67HtaCnsLn59xvhO/t2mLLTHAp667hJFxpp7bCtr2zOrR1NELzFXmKln/2lw/PvxMSvrA== + +"@cspell/dict-node@^5.0.1": + version "5.0.1" + resolved "https://registry.yarnpkg.com/@cspell/dict-node/-/dict-node-5.0.1.tgz#77e17c576a897a3391fce01c1cc5da60bb4c2268" + integrity sha512-lax/jGz9h3Dv83v8LHa5G0bf6wm8YVRMzbjJPG/9rp7cAGPtdrga+XANFq+B7bY5+jiSA3zvj10LUFCFjnnCCg== + +"@cspell/dict-npm@^5.1.4": + version "5.1.5" + resolved "https://registry.yarnpkg.com/@cspell/dict-npm/-/dict-npm-5.1.5.tgz#f3a7317988052494f776a6b60e3bffb3f063a006" + integrity sha512-oAOGWuJYU3DlO+cAsStKMWN8YEkBue25cRC9EwdiL5Z84nchU20UIoYrLfIQejMlZca+1GyrNeyxRAgn4KiivA== + +"@cspell/dict-php@^4.0.10": + version "4.0.10" + resolved "https://registry.yarnpkg.com/@cspell/dict-php/-/dict-php-4.0.10.tgz#e2ad4d3e30ec009824d9663a795f6281ae39caaf" + integrity sha512-NfTZdp6kcZDF1PvgQ6cY0zE4FUO5rSwNmBH/iwCBuaLfJAFQ97rgjxo+D2bic4CFwNjyHutnHPtjJBRANO5XQw== + +"@cspell/dict-powershell@^5.0.8": + version "5.0.9" + resolved "https://registry.yarnpkg.com/@cspell/dict-powershell/-/dict-powershell-5.0.9.tgz#124212c8ae616356a9119e8010723fb5ac85e317" + integrity sha512-Vi0h0rlxS39tgTyUtxI6L3BPHH7MLPkLWCYkNfb/buQuNJYNFdHiF4bqoqVdJ/7ZrfIfNg4i6rzocnwGRn2ruw== + +"@cspell/dict-public-licenses@^2.0.8": + version "2.0.8" + resolved "https://registry.yarnpkg.com/@cspell/dict-public-licenses/-/dict-public-licenses-2.0.8.tgz#ed8c3b5b22f28129cf3517821740599f05733b68" + integrity sha512-Sup+tFS7cDV0fgpoKtUqEZ6+fA/H+XUgBiqQ/Fbs6vUE3WCjJHOIVsP+udHuyMH7iBfJ4UFYOYeORcY4EaKdMg== + +"@cspell/dict-python@^4.2.6": + version "4.2.6" + resolved "https://registry.yarnpkg.com/@cspell/dict-python/-/dict-python-4.2.6.tgz#fce9950d59c6707442af04701d4ed7c7be333901" + integrity sha512-Hkz399qDGEbfXi9GYa2hDl7GahglI86JmS2F1KP8sfjLXofUgtnknyC5NWc86nzHcP38pZiPqPbTigyDYw5y8A== + dependencies: + "@cspell/dict-data-science" "^2.0.1" + +"@cspell/dict-r@^2.0.1": + version "2.0.1" + resolved "https://registry.yarnpkg.com/@cspell/dict-r/-/dict-r-2.0.1.tgz#73474fb7cce45deb9094ebf61083fbf5913f440a" + integrity sha512-KCmKaeYMLm2Ip79mlYPc8p+B2uzwBp4KMkzeLd5E6jUlCL93Y5Nvq68wV5fRLDRTf7N1LvofkVFWfDcednFOgA== + +"@cspell/dict-ruby@^5.0.3": + version "5.0.3" + resolved "https://registry.yarnpkg.com/@cspell/dict-ruby/-/dict-ruby-5.0.3.tgz#614e9a3d4dcd720e750c037b9dfb6001da8b25e0" + integrity sha512-V1xzv9hN6u8r6SM4CkYdsxs4ov8gjXXo0Twfx5kWhLXbEVxTXDMt7ohLTqpy2XlF5mutixZdbHMeFiAww8v+Ug== + +"@cspell/dict-rust@^4.0.5": + version "4.0.5" + resolved "https://registry.yarnpkg.com/@cspell/dict-rust/-/dict-rust-4.0.5.tgz#41f3e26fdd3d121c3a24c122d4a703abbb48c4c3" + integrity sha512-DIvlPRDemjKQy8rCqftAgGNZxY5Bg+Ps7qAIJjxkSjmMETyDgl0KTVuaJPt7EK4jJt6uCZ4ILy96npsHDPwoXA== + +"@cspell/dict-scala@^5.0.3": + version "5.0.3" + resolved "https://registry.yarnpkg.com/@cspell/dict-scala/-/dict-scala-5.0.3.tgz#85a469b2d139766b6307befc89243928e3d82b39" + integrity sha512-4yGb4AInT99rqprxVNT9TYb1YSpq58Owzq7zi3ZS5T0u899Y4VsxsBiOgHnQ/4W+ygi+sp+oqef8w8nABR2lkg== + +"@cspell/dict-software-terms@^4.1.3": + version "4.1.4" + resolved "https://registry.yarnpkg.com/@cspell/dict-software-terms/-/dict-software-terms-4.1.4.tgz#9b0da3e0674230d757e82ef67171db0764e17a16" + integrity sha512-AHS25sYEzWze/aFglp9ODKSu+phjkuGx+OLwIcmOnvyn8axtSq5GCn9UqS4XG1/Qn0UG2Lgb4i5PJbZ0QNPNXQ== + +"@cspell/dict-sql@^2.1.5": + version "2.1.5" + resolved "https://registry.yarnpkg.com/@cspell/dict-sql/-/dict-sql-2.1.5.tgz#068c7a8840d75418fd46a0b062c0ed2d5742f2b8" + integrity sha512-FmxanytHXss7GAWAXmgaxl3icTCW7YxlimyOSPNfm+njqeUDjw3kEv4mFNDDObBJv8Ec5AWCbUDkWIpkE3IpKg== + +"@cspell/dict-svelte@^1.0.2": + version "1.0.2" + resolved "https://registry.yarnpkg.com/@cspell/dict-svelte/-/dict-svelte-1.0.2.tgz#0c866b08a7a6b33bbc1a3bdbe6a1b484ca15cdaa" + integrity sha512-rPJmnn/GsDs0btNvrRBciOhngKV98yZ9SHmg8qI6HLS8hZKvcXc0LMsf9LLuMK1TmS2+WQFAan6qeqg6bBxL2Q== + +"@cspell/dict-swift@^2.0.1": + version "2.0.1" + resolved "https://registry.yarnpkg.com/@cspell/dict-swift/-/dict-swift-2.0.1.tgz#06ec86e52e9630c441d3c19605657457e33d7bb6" + integrity sha512-gxrCMUOndOk7xZFmXNtkCEeroZRnS2VbeaIPiymGRHj5H+qfTAzAKxtv7jJbVA3YYvEzWcVE2oKDP4wcbhIERw== + +"@cspell/dict-terraform@^1.0.1": + version "1.0.1" + resolved "https://registry.yarnpkg.com/@cspell/dict-terraform/-/dict-terraform-1.0.1.tgz#81648af2e7f19e8b3188be5e7b1a2d2b6627f58b" + integrity sha512-29lmUUnZgPh+ieZ5hunick8hzNIpNRtiJh9vAusNskPCrig3RTW6u7F+GG1a8uyslbzSw+Irjf40PTOan1OJJA== + +"@cspell/dict-typescript@^3.1.6": + version "3.1.6" + resolved "https://registry.yarnpkg.com/@cspell/dict-typescript/-/dict-typescript-3.1.6.tgz#2d5351786787bf3609da65ba17d9bc345995a36d" + integrity sha512-1beC6O4P/j23VuxX+i0+F7XqPVc3hhiAzGJHEKqnWf5cWAXQtg0xz3xQJ5MvYx2a7iLaSa+lu7+05vG9UHyu9Q== + +"@cspell/dict-vue@^3.0.0": + version "3.0.0" + resolved "https://registry.yarnpkg.com/@cspell/dict-vue/-/dict-vue-3.0.0.tgz#68ccb432ad93fcb0fd665352d075ae9a64ea9250" + integrity sha512-niiEMPWPV9IeRBRzZ0TBZmNnkK3olkOPYxC1Ny2AX4TGlYRajcW0WUtoSHmvvjZNfWLSg2L6ruiBeuPSbjnG6A== + +"@cspell/dynamic-import@8.14.4": + version "8.14.4" + resolved "https://registry.yarnpkg.com/@cspell/dynamic-import/-/dynamic-import-8.14.4.tgz#c3a8a9f5a8c6d6f8ccd2612a367bcc870dd07244" + integrity sha512-GjKsBJvPXp4dYRqsMn7n1zpnKbnpfJnlKLOVeoFBh8fi4n06G50xYr+G25CWX1WT3WFaALAavvVICEUPrVsuqg== + dependencies: + import-meta-resolve "^4.1.0" + +"@cspell/filetypes@8.14.4": + version "8.14.4" + resolved "https://registry.yarnpkg.com/@cspell/filetypes/-/filetypes-8.14.4.tgz#2f8b705d5b7df68817702899f9a94282ac4eef40" + integrity sha512-qd68dD7xTA4Mnf/wjIKYz2SkiTBshIM+yszOUtLa06YJm0aocoNQ25FHXyYEQYm9NQXCYnRWWA02sFMGs8Sv/w== + +"@cspell/strong-weak-map@8.14.4": + version "8.14.4" + resolved "https://registry.yarnpkg.com/@cspell/strong-weak-map/-/strong-weak-map-8.14.4.tgz#31a34bc7963d2c18d6cda391b2ddda58b9cb3061" + integrity sha512-Uyfck64TfVU24wAP3BLGQ5EsAfzIZiLfN90NhttpEM7GlOBmbGrEJd4hNOwfpYsE/TT80eGWQVPRTLr5SDbXFA== + +"@cspell/url@8.14.4": + version "8.14.4" + resolved "https://registry.yarnpkg.com/@cspell/url/-/url-8.14.4.tgz#46c17d7da0f04fe032ece932ed8137852062341c" + integrity sha512-htHhNF8WrM/NfaLSWuTYw0NqVgFRVHYSyHlRT3i/Yv5xvErld8Gw7C6ldm+0TLjoGlUe6X1VV72JSir7+yLp/Q== + +"@ctrl/tinycolor@^4.0.4": + version "4.1.0" + resolved "https://registry.yarnpkg.com/@ctrl/tinycolor/-/tinycolor-4.1.0.tgz#91a8f8120ffc9da2feb2a38f7862b300d5e9691a" + integrity sha512-WyOx8cJQ+FQus4Mm4uPIZA64gbk3Wxh0so5Lcii0aJifqwoVOlfFtorjLE0Hen4OYyHZMXDWqMmaQemBhgxFRQ== + +"@emmetio/abbreviation@^2.3.3": + version "2.3.3" + resolved "https://registry.yarnpkg.com/@emmetio/abbreviation/-/abbreviation-2.3.3.tgz#ed2b88fe37b972292d6026c7c540aaf887cecb6e" + integrity sha512-mgv58UrU3rh4YgbE/TzgLQwJ3pFsHHhCLqY20aJq+9comytTXUDNGG/SMtSeMJdkpxgXSXunBGLD8Boka3JyVA== + dependencies: + "@emmetio/scanner" "^1.0.4" + +"@emmetio/css-abbreviation@^2.1.8": + version "2.1.8" + resolved "https://registry.yarnpkg.com/@emmetio/css-abbreviation/-/css-abbreviation-2.1.8.tgz#b785313486eba6cb7eb623ad39378c4e1063dc00" + integrity sha512-s9yjhJ6saOO/uk1V74eifykk2CBYi01STTK3WlXWGOepyKa23ymJ053+DNQjpFcy1ingpaO7AxCcwLvHFY9tuw== + dependencies: + "@emmetio/scanner" "^1.0.4" + +"@emmetio/css-parser@^0.4.0": + version "0.4.0" + resolved "https://registry.yarnpkg.com/@emmetio/css-parser/-/css-parser-0.4.0.tgz#96135093480c79703df0e4f178f7f8f2b669fbc2" + integrity sha512-z7wkxRSZgrQHXVzObGkXG+Vmj3uRlpM11oCZ9pbaz0nFejvCDmAiNDpY75+wgXOcffKpj4rzGtwGaZxfJKsJxw== + dependencies: + "@emmetio/stream-reader" "^2.2.0" + "@emmetio/stream-reader-utils" "^0.1.0" + +"@emmetio/html-matcher@^1.3.0": + version "1.3.0" + resolved "https://registry.yarnpkg.com/@emmetio/html-matcher/-/html-matcher-1.3.0.tgz#43b7a71b91cdc511cb699cbe9c67bb5d4cab6754" + integrity sha512-NTbsvppE5eVyBMuyGfVu2CRrLvo7J4YHb6t9sBFLyY03WYhXET37qA4zOYUjBWFCRHO7pS1B9khERtY0f5JXPQ== + dependencies: + "@emmetio/scanner" "^1.0.0" + +"@emmetio/scanner@^1.0.0", "@emmetio/scanner@^1.0.4": + version "1.0.4" + resolved "https://registry.yarnpkg.com/@emmetio/scanner/-/scanner-1.0.4.tgz#e9cdc67194fd91f8b7eb141014be4f2d086c15f1" + integrity sha512-IqRuJtQff7YHHBk4G8YZ45uB9BaAGcwQeVzgj/zj8/UdOhtQpEIupUhSk8dys6spFIWVZVeK20CzGEnqR5SbqA== + +"@emmetio/stream-reader-utils@^0.1.0": + version "0.1.0" + resolved "https://registry.yarnpkg.com/@emmetio/stream-reader-utils/-/stream-reader-utils-0.1.0.tgz#244cb02c77ec2e74f78a9bd318218abc9c500a61" + integrity sha512-ZsZ2I9Vzso3Ho/pjZFsmmZ++FWeEd/txqybHTm4OgaZzdS8V9V/YYWQwg5TC38Z7uLWUV1vavpLLbjJtKubR1A== + +"@emmetio/stream-reader@^2.2.0": + version "2.2.0" + resolved "https://registry.yarnpkg.com/@emmetio/stream-reader/-/stream-reader-2.2.0.tgz#46cffea119a0a003312a21c2d9b5628cb5fcd442" + integrity sha512-fXVXEyFA5Yv3M3n8sUGT7+fvecGrZP4k6FnWWMSZVQf69kAq0LLpaBQLGcPR30m3zMmKYhECP4k/ZkzvhEW5kw== + +"@emnapi/runtime@^1.2.0": + version "1.2.0" + resolved "https://registry.yarnpkg.com/@emnapi/runtime/-/runtime-1.2.0.tgz#71d018546c3a91f3b51106530edbc056b9f2f2e3" + integrity sha512-bV21/9LQmcQeCPEg3BDFtvwL6cwiTMksYNWQQ4KOxCZikEGalWtenoZ0wCiukJINlGCIi2KXx01g4FoH/LxpzQ== + dependencies: + tslib "^2.4.0" + +"@esbuild/aix-ppc64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz#c7184a326533fcdf1b8ee0733e21c713b975575f" + integrity sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ== + +"@esbuild/android-arm64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz#09d9b4357780da9ea3a7dfb833a1f1ff439b4052" + integrity sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A== + +"@esbuild/android-arm@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.21.5.tgz#9b04384fb771926dfa6d7ad04324ecb2ab9b2e28" + integrity sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg== + +"@esbuild/android-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.21.5.tgz#29918ec2db754cedcb6c1b04de8cd6547af6461e" + integrity sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA== + +"@esbuild/darwin-arm64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz#e495b539660e51690f3928af50a76fb0a6ccff2a" + integrity sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ== + +"@esbuild/darwin-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz#c13838fa57372839abdddc91d71542ceea2e1e22" + integrity sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw== + +"@esbuild/freebsd-arm64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz#646b989aa20bf89fd071dd5dbfad69a3542e550e" + integrity sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g== + +"@esbuild/freebsd-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz#aa615cfc80af954d3458906e38ca22c18cf5c261" + integrity sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ== + +"@esbuild/linux-arm64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz#70ac6fa14f5cb7e1f7f887bcffb680ad09922b5b" + integrity sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q== + +"@esbuild/linux-arm@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz#fc6fd11a8aca56c1f6f3894f2bea0479f8f626b9" + integrity sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA== + +"@esbuild/linux-ia32@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz#3271f53b3f93e3d093d518d1649d6d68d346ede2" + integrity sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg== + +"@esbuild/linux-loong64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz#ed62e04238c57026aea831c5a130b73c0f9f26df" + integrity sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg== + +"@esbuild/linux-mips64el@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz#e79b8eb48bf3b106fadec1ac8240fb97b4e64cbe" + integrity sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg== + +"@esbuild/linux-ppc64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz#5f2203860a143b9919d383ef7573521fb154c3e4" + integrity sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w== + +"@esbuild/linux-riscv64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz#07bcafd99322d5af62f618cb9e6a9b7f4bb825dc" + integrity sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA== + +"@esbuild/linux-s390x@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz#b7ccf686751d6a3e44b8627ababc8be3ef62d8de" + integrity sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A== + +"@esbuild/linux-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz#6d8f0c768e070e64309af8004bb94e68ab2bb3b0" + integrity sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ== + +"@esbuild/netbsd-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz#bbe430f60d378ecb88decb219c602667387a6047" + integrity sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg== + +"@esbuild/openbsd-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz#99d1cf2937279560d2104821f5ccce220cb2af70" + integrity sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow== + +"@esbuild/sunos-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz#08741512c10d529566baba837b4fe052c8f3487b" + integrity sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg== + +"@esbuild/win32-arm64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz#675b7385398411240735016144ab2e99a60fc75d" + integrity sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A== + +"@esbuild/win32-ia32@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz#1bfc3ce98aa6ca9a0969e4d2af72144c59c1193b" + integrity sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA== + +"@esbuild/win32-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz#acad351d582d157bb145535db2a6ff53dd514b5c" + integrity sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw== + +"@expressive-code/core@^0.35.6": + version "0.35.6" + resolved "https://registry.yarnpkg.com/@expressive-code/core/-/core-0.35.6.tgz#7fd2f6b5c130588acd956c0d8fd042a2d8d096cb" + integrity sha512-xGqCkmfkgT7lr/rvmfnYdDSeTdCSp1otAHgoFS6wNEeO7wGDPpxdosVqYiIcQ8CfWUABh/pGqWG90q+MV3824A== + dependencies: + "@ctrl/tinycolor" "^4.0.4" + hast-util-select "^6.0.2" + hast-util-to-html "^9.0.1" + hast-util-to-text "^4.0.1" + hastscript "^9.0.0" + postcss "^8.4.38" + postcss-nested "^6.0.1" + unist-util-visit "^5.0.0" + unist-util-visit-parents "^6.0.1" + +"@expressive-code/plugin-frames@^0.35.6": + version "0.35.6" + resolved "https://registry.yarnpkg.com/@expressive-code/plugin-frames/-/plugin-frames-0.35.6.tgz#37566970a7e71cbb793cde8d9aeab8fd5e6c6abb" + integrity sha512-CqjSWjDJ3wabMJZfL9ZAzH5UAGKg7KWsf1TBzr4xvUbZvWoBtLA/TboBML0U1Ls8h/4TRCIvR4VEb8dv5+QG3w== + dependencies: + "@expressive-code/core" "^0.35.6" + +"@expressive-code/plugin-shiki@^0.35.6": + version "0.35.6" + resolved "https://registry.yarnpkg.com/@expressive-code/plugin-shiki/-/plugin-shiki-0.35.6.tgz#9f52f5e557a12fff702b94a414d3d41a5b0aebf8" + integrity sha512-xm+hzi9BsmhkDUGuyAWIydOAWer7Cs9cj8FM0t4HXaQ+qCubprT6wJZSKUxuvFJIUsIOqk1xXFaJzGJGnWtKMg== + dependencies: + "@expressive-code/core" "^0.35.6" + shiki "^1.1.7" + +"@expressive-code/plugin-text-markers@^0.35.6": + version "0.35.6" + resolved "https://registry.yarnpkg.com/@expressive-code/plugin-text-markers/-/plugin-text-markers-0.35.6.tgz#bcca76e8eb90dc44fa8fd937f28d5eb78a4bc0c8" + integrity sha512-/k9eWVZSCs+uEKHR++22Uu6eIbHWEciVHbIuD8frT8DlqTtHYaaiwHPncO6KFWnGDz5i/gL7oyl6XmOi/E6GVg== + dependencies: + "@expressive-code/core" "^0.35.6" + +"@img/sharp-darwin-arm64@0.33.5": + version "0.33.5" + resolved "https://registry.yarnpkg.com/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.33.5.tgz#ef5b5a07862805f1e8145a377c8ba6e98813ca08" + integrity sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ== + optionalDependencies: + "@img/sharp-libvips-darwin-arm64" "1.0.4" + +"@img/sharp-darwin-x64@0.33.5": + version "0.33.5" + resolved "https://registry.yarnpkg.com/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.33.5.tgz#e03d3451cd9e664faa72948cc70a403ea4063d61" + integrity sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q== + optionalDependencies: + "@img/sharp-libvips-darwin-x64" "1.0.4" + +"@img/sharp-libvips-darwin-arm64@1.0.4": + version "1.0.4" + resolved "https://registry.yarnpkg.com/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.0.4.tgz#447c5026700c01a993c7804eb8af5f6e9868c07f" + integrity sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg== + +"@img/sharp-libvips-darwin-x64@1.0.4": + version "1.0.4" + resolved "https://registry.yarnpkg.com/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.0.4.tgz#e0456f8f7c623f9dbfbdc77383caa72281d86062" + integrity sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ== + +"@img/sharp-libvips-linux-arm64@1.0.4": + version "1.0.4" + resolved "https://registry.yarnpkg.com/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.0.4.tgz#979b1c66c9a91f7ff2893556ef267f90ebe51704" + integrity sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA== + +"@img/sharp-libvips-linux-arm@1.0.5": + version "1.0.5" + resolved "https://registry.yarnpkg.com/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.0.5.tgz#99f922d4e15216ec205dcb6891b721bfd2884197" + integrity sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g== + +"@img/sharp-libvips-linux-s390x@1.0.4": + version "1.0.4" + resolved "https://registry.yarnpkg.com/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.0.4.tgz#f8a5eb1f374a082f72b3f45e2fb25b8118a8a5ce" + integrity sha512-u7Wz6ntiSSgGSGcjZ55im6uvTrOxSIS8/dgoVMoiGE9I6JAfU50yH5BoDlYA1tcuGS7g/QNtetJnxA6QEsCVTA== + +"@img/sharp-libvips-linux-x64@1.0.4": + version "1.0.4" + resolved "https://registry.yarnpkg.com/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.0.4.tgz#d4c4619cdd157774906e15770ee119931c7ef5e0" + integrity sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw== + +"@img/sharp-libvips-linuxmusl-arm64@1.0.4": + version "1.0.4" + resolved "https://registry.yarnpkg.com/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.0.4.tgz#166778da0f48dd2bded1fa3033cee6b588f0d5d5" + integrity sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA== + +"@img/sharp-libvips-linuxmusl-x64@1.0.4": + version "1.0.4" + resolved "https://registry.yarnpkg.com/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.0.4.tgz#93794e4d7720b077fcad3e02982f2f1c246751ff" + integrity sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw== + +"@img/sharp-linux-arm64@0.33.5": + version "0.33.5" + resolved "https://registry.yarnpkg.com/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.33.5.tgz#edb0697e7a8279c9fc829a60fc35644c4839bb22" + integrity sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA== + optionalDependencies: + "@img/sharp-libvips-linux-arm64" "1.0.4" + +"@img/sharp-linux-arm@0.33.5": + version "0.33.5" + resolved "https://registry.yarnpkg.com/@img/sharp-linux-arm/-/sharp-linux-arm-0.33.5.tgz#422c1a352e7b5832842577dc51602bcd5b6f5eff" + integrity sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ== + optionalDependencies: + "@img/sharp-libvips-linux-arm" "1.0.5" + +"@img/sharp-linux-s390x@0.33.5": + version "0.33.5" + resolved "https://registry.yarnpkg.com/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.33.5.tgz#f5c077926b48e97e4a04d004dfaf175972059667" + integrity sha512-y/5PCd+mP4CA/sPDKl2961b+C9d+vPAveS33s6Z3zfASk2j5upL6fXVPZi7ztePZ5CuH+1kW8JtvxgbuXHRa4Q== + optionalDependencies: + "@img/sharp-libvips-linux-s390x" "1.0.4" + +"@img/sharp-linux-x64@0.33.5": + version "0.33.5" + resolved "https://registry.yarnpkg.com/@img/sharp-linux-x64/-/sharp-linux-x64-0.33.5.tgz#d806e0afd71ae6775cc87f0da8f2d03a7c2209cb" + integrity sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA== + optionalDependencies: + "@img/sharp-libvips-linux-x64" "1.0.4" + +"@img/sharp-linuxmusl-arm64@0.33.5": + version "0.33.5" + resolved "https://registry.yarnpkg.com/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.33.5.tgz#252975b915894fb315af5deea174651e208d3d6b" + integrity sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g== + optionalDependencies: + "@img/sharp-libvips-linuxmusl-arm64" "1.0.4" + +"@img/sharp-linuxmusl-x64@0.33.5": + version "0.33.5" + resolved "https://registry.yarnpkg.com/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.33.5.tgz#3f4609ac5d8ef8ec7dadee80b560961a60fd4f48" + integrity sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw== + optionalDependencies: + "@img/sharp-libvips-linuxmusl-x64" "1.0.4" + +"@img/sharp-wasm32@0.33.5": + version "0.33.5" + resolved "https://registry.yarnpkg.com/@img/sharp-wasm32/-/sharp-wasm32-0.33.5.tgz#6f44f3283069d935bb5ca5813153572f3e6f61a1" + integrity sha512-ykUW4LVGaMcU9lu9thv85CbRMAwfeadCJHRsg2GmeRa/cJxsVY9Rbd57JcMxBkKHag5U/x7TSBpScF4U8ElVzg== + dependencies: + "@emnapi/runtime" "^1.2.0" + +"@img/sharp-win32-ia32@0.33.5": + version "0.33.5" + resolved "https://registry.yarnpkg.com/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.33.5.tgz#1a0c839a40c5351e9885628c85f2e5dfd02b52a9" + integrity sha512-T36PblLaTwuVJ/zw/LaH0PdZkRz5rd3SmMHX8GSmR7vtNSP5Z6bQkExdSK7xGWyxLw4sUknBuugTelgw2faBbQ== + +"@img/sharp-win32-x64@0.33.5": + version "0.33.5" + resolved "https://registry.yarnpkg.com/@img/sharp-win32-x64/-/sharp-win32-x64-0.33.5.tgz#56f00962ff0c4e0eb93d34a047d29fa995e3e342" + integrity sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg== + +"@jridgewell/gen-mapping@^0.3.5": + version "0.3.5" + resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz#dcce6aff74bdf6dad1a95802b69b04a2fcb1fb36" + integrity sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg== + dependencies: + "@jridgewell/set-array" "^1.2.1" + "@jridgewell/sourcemap-codec" "^1.4.10" + "@jridgewell/trace-mapping" "^0.3.24" + +"@jridgewell/resolve-uri@^3.1.0": + version "3.1.2" + resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz#7a0ee601f60f99a20c7c7c5ff0c80388c1189bd6" + integrity sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw== + +"@jridgewell/set-array@^1.2.1": + version "1.2.1" + resolved "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.2.1.tgz#558fb6472ed16a4c850b889530e6b36438c49280" + integrity sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A== + +"@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.14", "@jridgewell/sourcemap-codec@^1.4.15", "@jridgewell/sourcemap-codec@^1.5.0": + version "1.5.0" + resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz#3188bcb273a414b0d215fd22a58540b989b9409a" + integrity sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ== + +"@jridgewell/trace-mapping@^0.3.24", "@jridgewell/trace-mapping@^0.3.25": + version "0.3.25" + resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz#15f190e98895f3fc23276ee14bc76b675c2e50f0" + integrity sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ== + dependencies: + "@jridgewell/resolve-uri" "^3.1.0" + "@jridgewell/sourcemap-codec" "^1.4.14" + +"@mdx-js/mdx@^3.0.1": + version "3.0.1" + resolved "https://registry.yarnpkg.com/@mdx-js/mdx/-/mdx-3.0.1.tgz#617bd2629ae561fdca1bb88e3badd947f5a82191" + integrity sha512-eIQ4QTrOWyL3LWEe/bu6Taqzq2HQvHcyTMaOrI95P2/LmJE7AsfPfgJGuFLPVqBUE1BC1rik3VIhU+s9u72arA== + dependencies: + "@types/estree" "^1.0.0" + "@types/estree-jsx" "^1.0.0" + "@types/hast" "^3.0.0" + "@types/mdx" "^2.0.0" + collapse-white-space "^2.0.0" + devlop "^1.0.0" + estree-util-build-jsx "^3.0.0" + estree-util-is-identifier-name "^3.0.0" + estree-util-to-js "^2.0.0" + estree-walker "^3.0.0" + hast-util-to-estree "^3.0.0" + hast-util-to-jsx-runtime "^2.0.0" + markdown-extensions "^2.0.0" + periscopic "^3.0.0" + remark-mdx "^3.0.0" + remark-parse "^11.0.0" + remark-rehype "^11.0.0" + source-map "^0.7.0" + unified "^11.0.0" + unist-util-position-from-estree "^2.0.0" + unist-util-stringify-position "^4.0.0" + unist-util-visit "^5.0.0" + vfile "^6.0.0" + +"@nodelib/fs.scandir@2.1.5": + version "2.1.5" + resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5" + integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g== + dependencies: + "@nodelib/fs.stat" "2.0.5" + run-parallel "^1.1.9" + +"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2": + version "2.0.5" + resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b" + integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A== + +"@nodelib/fs.walk@^1.2.3": + version "1.2.8" + resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a" + integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg== + dependencies: + "@nodelib/fs.scandir" "2.1.5" + fastq "^1.6.0" + +"@oslojs/encoding@^0.4.1": + version "0.4.1" + resolved "https://registry.yarnpkg.com/@oslojs/encoding/-/encoding-0.4.1.tgz#1489e560041533214511e9e03626962d24e58e9f" + integrity sha512-hkjo6MuIK/kQR5CrGNdAPZhS01ZCXuWDRJ187zh6qqF2+yMHZpD9fAYpX8q2bOO6Ryhl3XpCT6kUX76N8hhm4Q== + +"@pagefind/darwin-arm64@1.1.1": + version "1.1.1" + resolved "https://registry.yarnpkg.com/@pagefind/darwin-arm64/-/darwin-arm64-1.1.1.tgz#39e75bc62c86cae62a6f903da3b1bacdcbce976c" + integrity sha512-tZ9tysUmQpFs2EqWG2+E1gc+opDAhSyZSsgKmFzhnWfkK02YHZhvL5XJXEZDqYy3s1FAKhwjTg8XDxneuBlDZQ== + +"@pagefind/darwin-x64@1.1.1": + version "1.1.1" + resolved "https://registry.yarnpkg.com/@pagefind/darwin-x64/-/darwin-x64-1.1.1.tgz#a238631d406b8d9ae2bc35e049f5781fc492a6d6" + integrity sha512-ChohLQ39dLwaxQv0jIQB/SavP3TM5K5ENfDTqIdzLkmfs3+JlzSDyQKcJFjTHYcCzQOZVeieeGq8PdqvLJxJxQ== + +"@pagefind/default-ui@^1.0.3": + version "1.1.1" + resolved "https://registry.yarnpkg.com/@pagefind/default-ui/-/default-ui-1.1.1.tgz#ba6c0f1f46f5a548ca3a79e79d3d9c400e783238" + integrity sha512-ZM0zDatWDnac/VGHhQCiM7UgA4ca8jpjA+VfuTJyHJBaxGqZMQnm4WoTz9E0KFcue1Bh9kxpu7uWFZfwpZZk0A== + +"@pagefind/linux-arm64@1.1.1": + version "1.1.1" + resolved "https://registry.yarnpkg.com/@pagefind/linux-arm64/-/linux-arm64-1.1.1.tgz#53542dc7873acac5d8fe58f529952bf5598a3bab" + integrity sha512-H5P6wDoCoAbdsWp0Zx0DxnLUrwTGWGLu/VI1rcN2CyFdY2EGSvPQsbGBMrseKRNuIrJDFtxHHHyjZ7UbzaM9EA== + +"@pagefind/linux-x64@1.1.1": + version "1.1.1" + resolved "https://registry.yarnpkg.com/@pagefind/linux-x64/-/linux-x64-1.1.1.tgz#3d37d7132bfa1bc23827ebb918ef3878566c88d6" + integrity sha512-yJs7tTYbL2MI3HT+ngs9E1BfUbY9M4/YzA0yEM5xBo4Xl8Yu8Qg2xZTOQ1/F6gwvMrjCUFo8EoACs6LRDhtMrQ== + +"@pagefind/windows-x64@1.1.1": + version "1.1.1" + resolved "https://registry.yarnpkg.com/@pagefind/windows-x64/-/windows-x64-1.1.1.tgz#3d227dd9fe8f11c573a9256a980a5d2f2b073cd7" + integrity sha512-b7/qPqgIl+lMzkQ8fJt51SfguB396xbIIR+VZ3YrL2tLuyifDJ1wL5mEm+ddmHxJ2Fki340paPcDan9en5OmAw== + +"@rollup/pluginutils@^5.1.0": + version "5.1.0" + resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-5.1.0.tgz#7e53eddc8c7f483a4ad0b94afb1f7f5fd3c771e0" + integrity sha512-XTIWOPPcpvyKI6L1NHo0lFlCyznUEyPmPY1mc3KpPVDYulHSTvyeLNVW00QTLIAFNhR3kYnJTQHeGqU4M3n09g== + dependencies: + "@types/estree" "^1.0.0" + estree-walker "^2.0.2" + picomatch "^2.3.1" + +"@rollup/rollup-android-arm-eabi@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.22.0.tgz#e8c16c336f060b4cb592f62eb4f0e543d79d51fe" + integrity sha512-/IZQvg6ZR0tAkEi4tdXOraQoWeJy9gbQ/cx4I7k9dJaCk9qrXEcdouxRVz5kZXt5C2bQ9pILoAA+KB4C/d3pfw== + +"@rollup/rollup-android-arm64@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.22.0.tgz#7a44160a14017fa744912d7037c7d81d6f8a46e7" + integrity sha512-ETHi4bxrYnvOtXeM7d4V4kZWixib2jddFacJjsOjwbgYSRsyXYtZHC4ht134OsslPIcnkqT+TKV4eU8rNBKyyQ== + +"@rollup/rollup-darwin-arm64@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.22.0.tgz#6122dc37d4a09521d8abe18925956d3b46cfbac9" + integrity sha512-ZWgARzhSKE+gVUX7QWaECoRQsPwaD8ZR0Oxb3aUpzdErTvlEadfQpORPXkKSdKbFci9v8MJfkTtoEHnnW9Ulng== + +"@rollup/rollup-darwin-x64@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.22.0.tgz#453f345899cbf544aa0d6f5808d24d2e42f605b7" + integrity sha512-h0ZAtOfHyio8Az6cwIGS+nHUfRMWBDO5jXB8PQCARVF6Na/G6XS2SFxDl8Oem+S5ZsHQgtsI7RT4JQnI1qrlaw== + +"@rollup/rollup-linux-arm-gnueabihf@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.22.0.tgz#3a32fa4e80a62a6d733014838b1123fe76b060fe" + integrity sha512-9pxQJSPwFsVi0ttOmqLY4JJ9pg9t1gKhK0JDbV1yUEETSx55fdyCjt39eBQ54OQCzAF0nVGO6LfEH1KnCPvelA== + +"@rollup/rollup-linux-arm-musleabihf@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.22.0.tgz#55d3953c54419e93efe124882a3103c8a2f65641" + integrity sha512-YJ5Ku5BmNJZb58A4qSEo3JlIG4d3G2lWyBi13ABlXzO41SsdnUKi3HQHe83VpwBVG4jHFTW65jOQb8qyoR+qzg== + +"@rollup/rollup-linux-arm64-gnu@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.22.0.tgz#cd626963b9962baf8e09d792e67b87269a5bcfff" + integrity sha512-U4G4u7f+QCqHlVg1Nlx+qapZy+QoG+NV6ux+upo/T7arNGwKvKP2kmGM4W5QTbdewWFgudQxi3kDNST9GT1/mg== + +"@rollup/rollup-linux-arm64-musl@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.22.0.tgz#ad209270c9937a27346fce5b0670cbdfb1e6a0a6" + integrity sha512-aQpNlKmx3amwkA3a5J6nlXSahE1ijl0L9KuIjVOUhfOh7uw2S4piR3mtpxpRtbnK809SBtyPsM9q15CPTsY7HQ== + +"@rollup/rollup-linux-powerpc64le-gnu@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.22.0.tgz#fdd173929a5bba8b7e8b37314380213d9604088f" + integrity sha512-9fx6Zj/7vve/Fp4iexUFRKb5+RjLCff6YTRQl4CoDhdMfDoobWmhAxQWV3NfShMzQk1Q/iCnageFyGfqnsmeqQ== + +"@rollup/rollup-linux-riscv64-gnu@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.22.0.tgz#90b11314fbf45d04083f658e08dc3b32fd713061" + integrity sha512-VWQiCcN7zBgZYLjndIEh5tamtnKg5TGxyZPWcN9zBtXBwfcGSZ5cHSdQZfQH/GB4uRxk0D3VYbOEe/chJhPGLQ== + +"@rollup/rollup-linux-s390x-gnu@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.22.0.tgz#46bb2f1135aeec646b720d6032d7c86915f8b2ec" + integrity sha512-EHmPnPWvyYqncObwqrosb/CpH3GOjE76vWVs0g4hWsDRUVhg61hBmlVg5TPXqF+g+PvIbqkC7i3h8wbn4Gp2Fg== + +"@rollup/rollup-linux-x64-gnu@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.22.0.tgz#d731a19af5f05eabcba871bda2eeb2fa8c8adb67" + integrity sha512-tsSWy3YQzmpjDKnQ1Vcpy3p9Z+kMFbSIesCdMNgLizDWFhrLZIoN21JSq01g+MZMDFF+Y1+4zxgrlqPjid5ohg== + +"@rollup/rollup-linux-x64-musl@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.22.0.tgz#5438b2dc38fe467444cf769146098be083022d0f" + integrity sha512-anr1Y11uPOQrpuU8XOikY5lH4Qu94oS6j0xrulHk3NkLDq19MlX8Ng/pVipjxBJ9a2l3+F39REZYyWQFkZ4/fw== + +"@rollup/rollup-win32-arm64-msvc@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.22.0.tgz#6bd66c198f80c8e7050cfd901701cfb9555d768a" + integrity sha512-7LB+Bh+Ut7cfmO0m244/asvtIGQr5pG5Rvjz/l1Rnz1kDzM02pSX9jPaS0p+90H5I1x4d1FkCew+B7MOnoatNw== + +"@rollup/rollup-win32-ia32-msvc@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.22.0.tgz#58daea1f1e65143c44c8f3311f30ff8eefa62bae" + integrity sha512-+3qZ4rer7t/QsC5JwMpcvCVPRcJt1cJrYS/TMJZzXIJbxWFQEVhrIc26IhB+5Z9fT9umfVc+Es2mOZgl+7jdJQ== + +"@rollup/rollup-win32-x64-msvc@4.22.0": + version "4.22.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.22.0.tgz#956948629f6b87de0bdf526b28d940221540bbb6" + integrity sha512-YdicNOSJONVx/vuPkgPTyRoAPx3GbknBZRCOUkK84FJ/YTfs/F0vl/YsMscrB6Y177d+yDRcj+JWMPMCgshwrA== + +"@shikijs/core@1.18.0": + version "1.18.0" + resolved "https://registry.yarnpkg.com/@shikijs/core/-/core-1.18.0.tgz#30dde8e53026dada606c4cf7f32d80a3f33d437c" + integrity sha512-VK4BNVCd2leY62Nm2JjyxtRLkyrZT/tv104O81eyaCjHq4Adceq2uJVFJJAIof6lT1mBwZrEo2qT/T+grv3MQQ== + dependencies: + "@shikijs/engine-javascript" "1.18.0" + "@shikijs/engine-oniguruma" "1.18.0" + "@shikijs/types" "1.18.0" + "@shikijs/vscode-textmate" "^9.2.2" + "@types/hast" "^3.0.4" + hast-util-to-html "^9.0.3" + +"@shikijs/engine-javascript@1.18.0": + version "1.18.0" + resolved "https://registry.yarnpkg.com/@shikijs/engine-javascript/-/engine-javascript-1.18.0.tgz#9888011c5d869a687b42e3e56c7243f15a73524b" + integrity sha512-qoP/aO/ATNwYAUw1YMdaip/YVEstMZEgrwhePm83Ll9OeQPuxDZd48szZR8oSQNQBT8m8UlWxZv8EA3lFuyI5A== + dependencies: + "@shikijs/types" "1.18.0" + "@shikijs/vscode-textmate" "^9.2.2" + oniguruma-to-js "0.4.3" + +"@shikijs/engine-oniguruma@1.18.0": + version "1.18.0" + resolved "https://registry.yarnpkg.com/@shikijs/engine-oniguruma/-/engine-oniguruma-1.18.0.tgz#7e57fd19b62b18cf2de382da684d042ee934f65d" + integrity sha512-B9u0ZKI/cud+TcmF8Chyh+R4V5qQVvyDOqXC2l2a4x73PBSBc6sZ0JRAX3eqyJswqir6ktwApUUGBYePdKnMJg== + dependencies: + "@shikijs/types" "1.18.0" + "@shikijs/vscode-textmate" "^9.2.2" + +"@shikijs/types@1.18.0": + version "1.18.0" + resolved "https://registry.yarnpkg.com/@shikijs/types/-/types-1.18.0.tgz#4c2d62d17f78cbfc051a15480ab4dfb0f06196c9" + integrity sha512-O9N36UEaGGrxv1yUrN2nye7gDLG5Uq0/c1LyfmxsvzNPqlHzWo9DI0A4+fhW2y3bGKuQu/fwS7EPdKJJCowcVA== + dependencies: + "@shikijs/vscode-textmate" "^9.2.2" + "@types/hast" "^3.0.4" + +"@shikijs/vscode-textmate@^9.2.2": + version "9.2.2" + resolved "https://registry.yarnpkg.com/@shikijs/vscode-textmate/-/vscode-textmate-9.2.2.tgz#24571f50625c7cd075f9efe0def8b9d2c0930ada" + integrity sha512-TMp15K+GGYrWlZM8+Lnj9EaHEFmOen0WJBrfa17hF7taDOYthuPPV0GWzfd/9iMij0akS/8Yw2ikquH7uVi/fg== + +"@types/acorn@^4.0.0": + version "4.0.6" + resolved "https://registry.yarnpkg.com/@types/acorn/-/acorn-4.0.6.tgz#d61ca5480300ac41a7d973dd5b84d0a591154a22" + integrity sha512-veQTnWP+1D/xbxVrPC3zHnCZRjSrKfhbMUlEA43iMZLu7EsnTtkJklIuwrCPbOi8YkvDQAiW05VQQFvvz9oieQ== + dependencies: + "@types/estree" "*" + +"@types/babel__core@^7.20.5": + version "7.20.5" + resolved "https://registry.yarnpkg.com/@types/babel__core/-/babel__core-7.20.5.tgz#3df15f27ba85319caa07ba08d0721889bb39c017" + integrity sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA== + dependencies: + "@babel/parser" "^7.20.7" + "@babel/types" "^7.20.7" + "@types/babel__generator" "*" + "@types/babel__template" "*" + "@types/babel__traverse" "*" + +"@types/babel__generator@*": + version "7.6.8" + resolved "https://registry.yarnpkg.com/@types/babel__generator/-/babel__generator-7.6.8.tgz#f836c61f48b1346e7d2b0d93c6dacc5b9535d3ab" + integrity sha512-ASsj+tpEDsEiFr1arWrlN6V3mdfjRMZt6LtK/Vp/kreFLnr5QH5+DhvD5nINYZXzwJvXeGq+05iUXcAzVrqWtw== + dependencies: + "@babel/types" "^7.0.0" + +"@types/babel__template@*": + version "7.4.4" + resolved "https://registry.yarnpkg.com/@types/babel__template/-/babel__template-7.4.4.tgz#5672513701c1b2199bc6dad636a9d7491586766f" + integrity sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A== + dependencies: + "@babel/parser" "^7.1.0" + "@babel/types" "^7.0.0" + +"@types/babel__traverse@*": + version "7.20.6" + resolved "https://registry.yarnpkg.com/@types/babel__traverse/-/babel__traverse-7.20.6.tgz#8dc9f0ae0f202c08d8d4dab648912c8d6038e3f7" + integrity sha512-r1bzfrm0tomOI8g1SzvCaQHo6Lcv6zu0EA+W2kHrt8dyrHQxGzBBL4kdkzIS+jBMV+EYcMAEAqXqYaLJq5rOZg== + dependencies: + "@babel/types" "^7.20.7" + +"@types/cookie@^0.6.0": + version "0.6.0" + resolved "https://registry.yarnpkg.com/@types/cookie/-/cookie-0.6.0.tgz#eac397f28bf1d6ae0ae081363eca2f425bedf0d5" + integrity sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA== + +"@types/debug@^4.0.0": + version "4.1.12" + resolved "https://registry.yarnpkg.com/@types/debug/-/debug-4.1.12.tgz#a155f21690871953410df4b6b6f53187f0500917" + integrity sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ== + dependencies: + "@types/ms" "*" + +"@types/estree-jsx@^1.0.0": + version "1.0.5" + resolved "https://registry.yarnpkg.com/@types/estree-jsx/-/estree-jsx-1.0.5.tgz#858a88ea20f34fe65111f005a689fa1ebf70dc18" + integrity sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg== + dependencies: + "@types/estree" "*" + +"@types/estree@*", "@types/estree@^1.0.0": + version "1.0.6" + resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.6.tgz#628effeeae2064a1b4e79f78e81d87b7e5fc7b50" + integrity sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw== + +"@types/estree@1.0.5": + version "1.0.5" + resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.5.tgz#a6ce3e556e00fd9895dd872dd172ad0d4bd687f4" + integrity sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw== + +"@types/hast@^3.0.0", "@types/hast@^3.0.4": + version "3.0.4" + resolved "https://registry.yarnpkg.com/@types/hast/-/hast-3.0.4.tgz#1d6b39993b82cea6ad783945b0508c25903e15aa" + integrity sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ== + dependencies: + "@types/unist" "*" + +"@types/katex@^0.16.0": + version "0.16.7" + resolved "https://registry.yarnpkg.com/@types/katex/-/katex-0.16.7.tgz#03ab680ab4fa4fbc6cb46ecf987ecad5d8019868" + integrity sha512-HMwFiRujE5PjrgwHQ25+bsLJgowjGjm5Z8FVSf0N6PwgJrwxH0QxzHYDcKsTfV3wva0vzrpqMTJS2jXPr5BMEQ== + +"@types/mdast@^4.0.0", "@types/mdast@^4.0.4": + version "4.0.4" + resolved "https://registry.yarnpkg.com/@types/mdast/-/mdast-4.0.4.tgz#7ccf72edd2f1aa7dd3437e180c64373585804dd6" + integrity sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA== + dependencies: + "@types/unist" "*" + +"@types/mdx@^2.0.0": + version "2.0.13" + resolved "https://registry.yarnpkg.com/@types/mdx/-/mdx-2.0.13.tgz#68f6877043d377092890ff5b298152b0a21671bd" + integrity sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw== + +"@types/ms@*": + version "0.7.34" + resolved "https://registry.yarnpkg.com/@types/ms/-/ms-0.7.34.tgz#10964ba0dee6ac4cd462e2795b6bebd407303433" + integrity sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g== + +"@types/nlcst@^2.0.0": + version "2.0.3" + resolved "https://registry.yarnpkg.com/@types/nlcst/-/nlcst-2.0.3.tgz#31cad346eaab48a9a8a58465d3d05e2530dda762" + integrity sha512-vSYNSDe6Ix3q+6Z7ri9lyWqgGhJTmzRjZRqyq15N0Z/1/UnVsno9G/N40NBijoYx2seFDIl0+B2mgAb9mezUCA== + dependencies: + "@types/unist" "*" + +"@types/node@*": + version "22.5.5" + resolved "https://registry.yarnpkg.com/@types/node/-/node-22.5.5.tgz#52f939dd0f65fc552a4ad0b392f3c466cc5d7a44" + integrity sha512-Xjs4y5UPO/CLdzpgR6GirZJx36yScjh73+2NlLlkFRSoQN8B0DpfXPdZGnvVmLRLOsqDpOfTNv7D9trgGhmOIA== + dependencies: + undici-types "~6.19.2" + +"@types/node@^17.0.5": + version "17.0.45" + resolved "https://registry.yarnpkg.com/@types/node/-/node-17.0.45.tgz#2c0fafd78705e7a18b7906b5201a522719dc5190" + integrity sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw== + +"@types/picomatch@2.3.3": + version "2.3.3" + resolved "https://registry.yarnpkg.com/@types/picomatch/-/picomatch-2.3.3.tgz#be60498568c19e989e43fb39aa84be1ed3655e92" + integrity sha512-Yll76ZHikRFCyz/pffKGjrCwe/le2CDwOP5F210KQo27kpRE46U2rDnzikNlVn6/ezH3Mhn46bJMTfeVTtcYMg== + +"@types/sax@^1.2.1": + version "1.2.7" + resolved "https://registry.yarnpkg.com/@types/sax/-/sax-1.2.7.tgz#ba5fe7df9aa9c89b6dff7688a19023dd2963091d" + integrity sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A== + dependencies: + "@types/node" "*" + +"@types/unist@*", "@types/unist@^3.0.0": + version "3.0.3" + resolved "https://registry.yarnpkg.com/@types/unist/-/unist-3.0.3.tgz#acaab0f919ce69cce629c2d4ed2eb4adc1b6c20c" + integrity sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q== + +"@types/unist@^2.0.0": + version "2.0.11" + resolved "https://registry.yarnpkg.com/@types/unist/-/unist-2.0.11.tgz#11af57b127e32487774841f7a4e54eab166d03c4" + integrity sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA== + +"@ungap/structured-clone@^1.0.0": + version "1.2.0" + resolved "https://registry.yarnpkg.com/@ungap/structured-clone/-/structured-clone-1.2.0.tgz#756641adb587851b5ccb3e095daf27ae581c8406" + integrity sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ== + +"@volar/kit@~2.4.0": + version "2.4.5" + resolved "https://registry.yarnpkg.com/@volar/kit/-/kit-2.4.5.tgz#3944d8f67d1d5ee5ade28bc4624d3ce76c7b43c0" + integrity sha512-ZzyErW5UiDfiIuJ/lpqc2Kx5PHDGDZ/bPlPJYpRcxlrn8Z8aDhRlsLHkNKcNiH65TmNahk2kbLaiejiqu6BD3A== + dependencies: + "@volar/language-service" "2.4.5" + "@volar/typescript" "2.4.5" + typesafe-path "^0.2.2" + vscode-languageserver-textdocument "^1.0.11" + vscode-uri "^3.0.8" + +"@volar/language-core@2.4.5", "@volar/language-core@~2.4.0": + version "2.4.5" + resolved "https://registry.yarnpkg.com/@volar/language-core/-/language-core-2.4.5.tgz#af8ba724b05fc4dce2339c49662e732e9c22c897" + integrity sha512-F4tA0DCO5Q1F5mScHmca0umsi2ufKULAnMOVBfMsZdT4myhVl4WdKRwCaKcfOkIEuyrAVvtq1ESBdZ+rSyLVww== + dependencies: + "@volar/source-map" "2.4.5" + +"@volar/language-server@~2.4.0": + version "2.4.5" + resolved "https://registry.yarnpkg.com/@volar/language-server/-/language-server-2.4.5.tgz#87116cfef3e2d58b0e43ccbb3114e1f395e9ee81" + integrity sha512-l5PswE0JzCtstTlwBUpikeSa3lNUBJhTuWtj9KclZTGi2Uex4RcqGOhTiDsUUtvdv/hEuYCxGq1EdJJPlQsD/g== + dependencies: + "@volar/language-core" "2.4.5" + "@volar/language-service" "2.4.5" + "@volar/typescript" "2.4.5" + path-browserify "^1.0.1" + request-light "^0.7.0" + vscode-languageserver "^9.0.1" + vscode-languageserver-protocol "^3.17.5" + vscode-languageserver-textdocument "^1.0.11" + vscode-uri "^3.0.8" + +"@volar/language-service@2.4.5", "@volar/language-service@~2.4.0": + version "2.4.5" + resolved "https://registry.yarnpkg.com/@volar/language-service/-/language-service-2.4.5.tgz#298ee42535a48075eac35a90a6a0258e457ba3a0" + integrity sha512-xiFlL0aViGg6JhwAXyohPrdlID13uom8WQg6DWYaV8ob8RRy+zoLlBUI8SpQctwlWEO9poyrYK01revijAwkcw== + dependencies: + "@volar/language-core" "2.4.5" + vscode-languageserver-protocol "^3.17.5" + vscode-languageserver-textdocument "^1.0.11" + vscode-uri "^3.0.8" + +"@volar/source-map@2.4.5": + version "2.4.5" + resolved "https://registry.yarnpkg.com/@volar/source-map/-/source-map-2.4.5.tgz#81223a06321aaa067b40619189b44a9f0b7ac2d8" + integrity sha512-varwD7RaKE2J/Z+Zu6j3mNNJbNT394qIxXwdvz/4ao/vxOfyClZpSDtLKkwWmecinkOVos5+PWkWraelfMLfpw== + +"@volar/typescript@2.4.5", "@volar/typescript@~2.4.0": + version "2.4.5" + resolved "https://registry.yarnpkg.com/@volar/typescript/-/typescript-2.4.5.tgz#1210c1e8561ac20af46348ceaf8e6e96c797063f" + integrity sha512-mcT1mHvLljAEtHviVcBuOyAwwMKz1ibXTi5uYtP/pf4XxoAzpdkQ+Br2IC0NPCvLCbjPZmbf3I0udndkfB1CDg== + dependencies: + "@volar/language-core" "2.4.5" + path-browserify "^1.0.1" + vscode-uri "^3.0.8" + +"@vscode/emmet-helper@^2.9.3": + version "2.9.3" + resolved "https://registry.yarnpkg.com/@vscode/emmet-helper/-/emmet-helper-2.9.3.tgz#8a8b228981fcf2d9346fdca77b9ad5a31dc09dba" + integrity sha512-rB39LHWWPQYYlYfpv9qCoZOVioPCftKXXqrsyqN1mTWZM6dTnONT63Db+03vgrBbHzJN45IrgS/AGxw9iiqfEw== + dependencies: + emmet "^2.4.3" + jsonc-parser "^2.3.0" + vscode-languageserver-textdocument "^1.0.1" + vscode-languageserver-types "^3.15.1" + vscode-uri "^2.1.2" + +"@vscode/l10n@^0.0.18": + version "0.0.18" + resolved "https://registry.yarnpkg.com/@vscode/l10n/-/l10n-0.0.18.tgz#916d3a5e960dbab47c1c56f58a7cb5087b135c95" + integrity sha512-KYSIHVmslkaCDyw013pphY+d7x1qV8IZupYfeIfzNA+nsaWHbn5uPuQRvdRFsa9zFzGeudPuoGoZ1Op4jrJXIQ== + +acorn-jsx@^5.0.0: + version "5.3.2" + resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937" + integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ== + +acorn@^8.0.0, acorn@^8.12.1: + version "8.12.1" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.12.1.tgz#71616bdccbe25e27a54439e0046e89ca76df2248" + integrity sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg== + +ajv@^8.11.0: + version "8.17.1" + resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.17.1.tgz#37d9a5c776af6bc92d7f4f9510eba4c0a60d11a6" + integrity sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g== + dependencies: + fast-deep-equal "^3.1.3" + fast-uri "^3.0.1" + json-schema-traverse "^1.0.0" + require-from-string "^2.0.2" + +ansi-align@^3.0.1: + version "3.0.1" + resolved "https://registry.yarnpkg.com/ansi-align/-/ansi-align-3.0.1.tgz#0cdf12e111ace773a86e9a1fad1225c43cb19a59" + integrity sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w== + dependencies: + string-width "^4.1.0" + +ansi-regex@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304" + integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== + +ansi-regex@^6.0.1: + version "6.1.0" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.1.0.tgz#95ec409c69619d6cb1b8b34f14b660ef28ebd654" + integrity sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA== + +ansi-styles@^3.2.1: + version "3.2.1" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d" + integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA== + dependencies: + color-convert "^1.9.0" + +ansi-styles@^4.0.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" + integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== + dependencies: + color-convert "^2.0.1" + +ansi-styles@^6.1.0: + version "6.2.1" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.2.1.tgz#0e62320cf99c21afff3b3012192546aacbfb05c5" + integrity sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug== + +anymatch@~3.1.2: + version "3.1.3" + resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e" + integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== + dependencies: + normalize-path "^3.0.0" + picomatch "^2.0.4" + +arg@^5.0.0: + version "5.0.2" + resolved "https://registry.yarnpkg.com/arg/-/arg-5.0.2.tgz#c81433cc427c92c4dcf4865142dbca6f15acd59c" + integrity sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg== + +argparse@^1.0.7: + version "1.0.10" + resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911" + integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg== + dependencies: + sprintf-js "~1.0.2" + +argparse@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38" + integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q== + +aria-query@^5.3.0: + version "5.3.1" + resolved "https://registry.yarnpkg.com/aria-query/-/aria-query-5.3.1.tgz#ebcb2c0d7fc43e68e4cb22f774d1209cb627ab42" + integrity sha512-Z/ZeOgVl7bcSYZ/u/rh0fOpvEpq//LZmdbkXyc7syVzjPAhfOa9ebsdTSjEBDU4vs5nC98Kfduj1uFo0qyET3g== + +array-iterate@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/array-iterate/-/array-iterate-2.0.1.tgz#6efd43f8295b3fee06251d3d62ead4bd9805dd24" + integrity sha512-I1jXZMjAgCMmxT4qxXfPXa6SthSoE8h6gkSI9BGGNv8mP8G/v0blc+qFnZu6K42vTOiuME596QaLO0TP3Lk0xg== + +array-timsort@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/array-timsort/-/array-timsort-1.0.3.tgz#3c9e4199e54fb2b9c3fe5976396a21614ef0d926" + integrity sha512-/+3GRL7dDAGEfM6TseQk/U+mi18TU2Ms9I3UlLdUMhz2hbvGNTKdj9xniwXfUqgYhHxRx0+8UnKkvlNwVU+cWQ== + +astring@^1.8.0: + version "1.9.0" + resolved "https://registry.yarnpkg.com/astring/-/astring-1.9.0.tgz#cc73e6062a7eb03e7d19c22d8b0b3451fd9bfeef" + integrity sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg== + +astro-expressive-code@^0.35.6: + version "0.35.6" + resolved "https://registry.yarnpkg.com/astro-expressive-code/-/astro-expressive-code-0.35.6.tgz#5029d44cba99c674e1225968de1382466b997f3d" + integrity sha512-1U4KrvFuodaCV3z4I1bIR16SdhQlPkolGsYTtiANxPZUVv/KitGSCTjzksrkPonn1XuwVqvnwmUUVzTLWngnBA== + dependencies: + rehype-expressive-code "^0.35.6" + +astro@^4.15.3: + version "4.15.8" + resolved "https://registry.yarnpkg.com/astro/-/astro-4.15.8.tgz#046190f8c9c719b278c13f5e8e35943bf178a7b2" + integrity sha512-pdXjtRF6O1xChiPAUF32R7oVRTW7AK1/Oy/JqPNhLfbelO0l6C7cLdSEuSLektwOEnMhOVXqccetjBs7HPaoxA== + dependencies: + "@astrojs/compiler" "^2.10.3" + "@astrojs/internal-helpers" "0.4.1" + "@astrojs/markdown-remark" "5.2.0" + "@astrojs/telemetry" "3.1.0" + "@babel/core" "^7.25.2" + "@babel/plugin-transform-react-jsx" "^7.25.2" + "@babel/types" "^7.25.6" + "@oslojs/encoding" "^0.4.1" + "@rollup/pluginutils" "^5.1.0" + "@types/babel__core" "^7.20.5" + "@types/cookie" "^0.6.0" + acorn "^8.12.1" + aria-query "^5.3.0" + axobject-query "^4.1.0" + boxen "7.1.1" + ci-info "^4.0.0" + clsx "^2.1.1" + common-ancestor-path "^1.0.1" + cookie "^0.6.0" + cssesc "^3.0.0" + debug "^4.3.7" + deterministic-object-hash "^2.0.2" + devalue "^5.0.0" + diff "^5.2.0" + dlv "^1.1.3" + dset "^3.1.3" + es-module-lexer "^1.5.4" + esbuild "^0.21.5" + estree-walker "^3.0.3" + fast-glob "^3.3.2" + fastq "^1.17.1" + flattie "^1.1.1" + github-slugger "^2.0.0" + gray-matter "^4.0.3" + html-escaper "^3.0.3" + http-cache-semantics "^4.1.1" + js-yaml "^4.1.0" + kleur "^4.1.5" + magic-string "^0.30.11" + magicast "^0.3.5" + micromatch "^4.0.8" + mrmime "^2.0.0" + neotraverse "^0.6.18" + ora "^8.1.0" + p-limit "^6.1.0" + p-queue "^8.0.1" + preferred-pm "^4.0.0" + prompts "^2.4.2" + rehype "^13.0.1" + semver "^7.6.3" + shiki "^1.16.2" + string-width "^7.2.0" + strip-ansi "^7.1.0" + tinyexec "^0.3.0" + tsconfck "^3.1.3" + unist-util-visit "^5.0.0" + vfile "^6.0.3" + vite "^5.4.3" + vitefu "^1.0.2" + which-pm "^3.0.0" + xxhash-wasm "^1.0.2" + yargs-parser "^21.1.1" + zod "^3.23.8" + zod-to-json-schema "^3.23.2" + zod-to-ts "^1.2.0" + optionalDependencies: + sharp "^0.33.3" + +axobject-query@^4.1.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/axobject-query/-/axobject-query-4.1.0.tgz#28768c76d0e3cff21bc62a9e2d0b6ac30042a1ee" + integrity sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ== + +b4a@^1.6.4, b4a@^1.6.6: + version "1.6.6" + resolved "https://registry.yarnpkg.com/b4a/-/b4a-1.6.6.tgz#a4cc349a3851987c3c4ac2d7785c18744f6da9ba" + integrity sha512-5Tk1HLk6b6ctmjIkAcU/Ujv/1WqiDl0F0JdRCR80VsOcUlHcu7pWeWRlOqQLHfDEsVx9YH/aif5AG4ehoCtTmg== + +bail@^2.0.0: + version "2.0.2" + resolved "https://registry.yarnpkg.com/bail/-/bail-2.0.2.tgz#d26f5cd8fe5d6f832a31517b9f7c356040ba6d5d" + integrity sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw== + +bare-events@^2.0.0, bare-events@^2.2.0: + version "2.4.2" + resolved "https://registry.yarnpkg.com/bare-events/-/bare-events-2.4.2.tgz#3140cca7a0e11d49b3edc5041ab560659fd8e1f8" + integrity sha512-qMKFd2qG/36aA4GwvKq8MxnPgCQAmBWmSyLWsJcbn8v03wvIPQ/hG1Ms8bPzndZxMDoHpxez5VOS+gC9Yi24/Q== + +bare-fs@^2.1.1: + version "2.3.5" + resolved "https://registry.yarnpkg.com/bare-fs/-/bare-fs-2.3.5.tgz#05daa8e8206aeb46d13c2fe25a2cd3797b0d284a" + integrity sha512-SlE9eTxifPDJrT6YgemQ1WGFleevzwY+XAP1Xqgl56HtcrisC2CHCZ2tq6dBpcH2TnNxwUEUGhweo+lrQtYuiw== + dependencies: + bare-events "^2.0.0" + bare-path "^2.0.0" + bare-stream "^2.0.0" + +bare-os@^2.1.0: + version "2.4.4" + resolved "https://registry.yarnpkg.com/bare-os/-/bare-os-2.4.4.tgz#01243392eb0a6e947177bb7c8a45123d45c9b1a9" + integrity sha512-z3UiI2yi1mK0sXeRdc4O1Kk8aOa/e+FNWZcTiPB/dfTWyLypuE99LibgRaQki914Jq//yAWylcAt+mknKdixRQ== + +bare-path@^2.0.0, bare-path@^2.1.0: + version "2.1.3" + resolved "https://registry.yarnpkg.com/bare-path/-/bare-path-2.1.3.tgz#594104c829ef660e43b5589ec8daef7df6cedb3e" + integrity sha512-lh/eITfU8hrj9Ru5quUp0Io1kJWIk1bTjzo7JH1P5dWmQ2EL4hFUlfI8FonAhSlgIfhn63p84CDY/x+PisgcXA== + dependencies: + bare-os "^2.1.0" + +bare-stream@^2.0.0: + version "2.3.0" + resolved "https://registry.yarnpkg.com/bare-stream/-/bare-stream-2.3.0.tgz#5bef1cab8222517315fca1385bd7f08dff57f435" + integrity sha512-pVRWciewGUeCyKEuRxwv06M079r+fRjAQjBEK2P6OYGrO43O+Z0LrPZZEjlc4mB6C2RpZ9AxJ1s7NLEtOHO6eA== + dependencies: + b4a "^1.6.6" + streamx "^2.20.0" + +base-64@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/base-64/-/base-64-1.0.0.tgz#09d0f2084e32a3fd08c2475b973788eee6ae8f4a" + integrity sha512-kwDPIFCGx0NZHog36dj+tHiwP4QMzsZ3AgMViUBKI0+V5n4U0ufTCUMhnQ04diaRI8EX/QcPfql7zlhZ7j4zgg== + +base64-js@^1.3.1: + version "1.5.1" + resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a" + integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA== + +bcp-47-match@^2.0.0: + version "2.0.3" + resolved "https://registry.yarnpkg.com/bcp-47-match/-/bcp-47-match-2.0.3.tgz#603226f6e5d3914a581408be33b28a53144b09d0" + integrity sha512-JtTezzbAibu8G0R9op9zb3vcWZd9JF6M0xOYGPn0fNCd7wOpRB1mU2mH9T8gaBGbAAyIIVgB2G7xG0GP98zMAQ== + +bcp-47@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/bcp-47/-/bcp-47-2.1.0.tgz#7e80734c3338fe8320894981dccf4968c3092df6" + integrity sha512-9IIS3UPrvIa1Ej+lVDdDwO7zLehjqsaByECw0bu2RRGP73jALm6FYbzI5gWbgHLvNdkvfXB5YrSbocZdOS0c0w== + dependencies: + is-alphabetical "^2.0.0" + is-alphanumerical "^2.0.0" + is-decimal "^2.0.0" + +binary-extensions@^2.0.0: + version "2.3.0" + resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.3.0.tgz#f6e14a97858d327252200242d4ccfe522c445522" + integrity sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw== + +bl@^4.0.3: + version "4.1.0" + resolved "https://registry.yarnpkg.com/bl/-/bl-4.1.0.tgz#451535264182bec2fbbc83a62ab98cf11d9f7b3a" + integrity sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w== + dependencies: + buffer "^5.5.0" + inherits "^2.0.4" + readable-stream "^3.4.0" + +boolbase@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/boolbase/-/boolbase-1.0.0.tgz#68dff5fbe60c51eb37725ea9e3ed310dcc1e776e" + integrity sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww== + +boxen@7.1.1: + version "7.1.1" + resolved "https://registry.yarnpkg.com/boxen/-/boxen-7.1.1.tgz#f9ba525413c2fec9cdb88987d835c4f7cad9c8f4" + integrity sha512-2hCgjEmP8YLWQ130n2FerGv7rYpfBmnmp9Uy2Le1vge6X3gZIfSmEzP5QTDElFxcvVcXlEn8Aq6MU/PZygIOog== + dependencies: + ansi-align "^3.0.1" + camelcase "^7.0.1" + chalk "^5.2.0" + cli-boxes "^3.0.0" + string-width "^5.1.2" + type-fest "^2.13.0" + widest-line "^4.0.1" + wrap-ansi "^8.1.0" + +braces@^3.0.3, braces@~3.0.2: + version "3.0.3" + resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.3.tgz#490332f40919452272d55a8480adc0c441358789" + integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA== + dependencies: + fill-range "^7.1.1" + +browserslist@^4.23.1: + version "4.23.3" + resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.23.3.tgz#debb029d3c93ebc97ffbc8d9cbb03403e227c800" + integrity sha512-btwCFJVjI4YWDNfau8RhZ+B1Q/VLoUITrm3RlP6y1tYGWIOa+InuYiRGXUBXo8nA1qKmHMyLB/iVQg5TT4eFoA== + dependencies: + caniuse-lite "^1.0.30001646" + electron-to-chromium "^1.5.4" + node-releases "^2.0.18" + update-browserslist-db "^1.1.0" + +buffer@^5.5.0: + version "5.7.1" + resolved "https://registry.yarnpkg.com/buffer/-/buffer-5.7.1.tgz#ba62e7c13133053582197160851a8f648e99eed0" + integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ== + dependencies: + base64-js "^1.3.1" + ieee754 "^1.1.13" + +callsites@^3.0.0, callsites@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73" + integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== + +camelcase@^7.0.1: + version "7.0.1" + resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-7.0.1.tgz#f02e50af9fd7782bc8b88a3558c32fd3a388f048" + integrity sha512-xlx1yCK2Oc1APsPXDL2LdlNP6+uu8OCDdhOBSVT279M/S+y75O30C2VuD8T2ogdePBBl7PfPF4504tnLgX3zfw== + +caniuse-lite@^1.0.30001646: + version "1.0.30001662" + resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001662.tgz#3574b22dfec54a3f3b6787331da1040fe8e763ec" + integrity sha512-sgMUVwLmGseH8ZIrm1d51UbrhqMCH3jvS7gF/M6byuHOnKyLOBL7W8yz5V02OHwgLGA36o/AFhWzzh4uc5aqTA== + +ccount@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/ccount/-/ccount-2.0.1.tgz#17a3bf82302e0870d6da43a01311a8bc02a3ecf5" + integrity sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg== + +chalk-template@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/chalk-template/-/chalk-template-1.1.0.tgz#ffc55db6dd745e9394b85327c8ac8466edb7a7b1" + integrity sha512-T2VJbcDuZQ0Tb2EWwSotMPJjgpy1/tGee1BTpUNsGZ/qgNjV2t7Mvu+d4600U564nbLesN1x2dPL+xii174Ekg== + dependencies: + chalk "^5.2.0" + +chalk@^2.4.2: + version "2.4.2" + resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424" + 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" + +chalk@^5.2.0, chalk@^5.3.0: + version "5.3.0" + resolved "https://registry.yarnpkg.com/chalk/-/chalk-5.3.0.tgz#67c20a7ebef70e7f3970a01f90fa210cb6860385" + integrity sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w== + +character-entities-html4@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/character-entities-html4/-/character-entities-html4-2.1.0.tgz#1f1adb940c971a4b22ba39ddca6b618dc6e56b2b" + integrity sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA== + +character-entities-legacy@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz#76bc83a90738901d7bc223a9e93759fdd560125b" + integrity sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ== + +character-entities@^2.0.0: + version "2.0.2" + resolved "https://registry.yarnpkg.com/character-entities/-/character-entities-2.0.2.tgz#2d09c2e72cd9523076ccb21157dff66ad43fcc22" + integrity sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ== + +character-reference-invalid@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz#85c66b041e43b47210faf401278abf808ac45cb9" + integrity sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw== + +chokidar@^3.5.3: + version "3.6.0" + resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.6.0.tgz#197c6cc669ef2a8dc5e7b4d97ee4e092c3eb0d5b" + integrity sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw== + dependencies: + anymatch "~3.1.2" + braces "~3.0.2" + glob-parent "~5.1.2" + is-binary-path "~2.1.0" + is-glob "~4.0.1" + normalize-path "~3.0.0" + readdirp "~3.6.0" + optionalDependencies: + fsevents "~2.3.2" + +chownr@^1.1.1: + version "1.1.4" + resolved "https://registry.yarnpkg.com/chownr/-/chownr-1.1.4.tgz#6fc9d7b42d32a583596337666e7d08084da2cc6b" + integrity sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg== + +ci-info@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-4.0.0.tgz#65466f8b280fc019b9f50a5388115d17a63a44f2" + integrity sha512-TdHqgGf9odd8SXNuxtUBVx8Nv+qZOejE6qyqiy5NtbYYQOeFa6zmHkxlPzmaLxWWHsU6nJmB7AETdVPi+2NBUg== + +clear-module@^4.1.2: + version "4.1.2" + resolved "https://registry.yarnpkg.com/clear-module/-/clear-module-4.1.2.tgz#5a58a5c9f8dccf363545ad7284cad3c887352a80" + integrity sha512-LWAxzHqdHsAZlPlEyJ2Poz6AIs384mPeqLVCru2p0BrP9G/kVGuhNyZYClLO6cXlnuJjzC8xtsJIuMjKqLXoAw== + dependencies: + parent-module "^2.0.0" + resolve-from "^5.0.0" + +cli-boxes@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/cli-boxes/-/cli-boxes-3.0.0.tgz#71a10c716feeba005e4504f36329ef0b17cf3145" + integrity sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g== + +cli-cursor@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-5.0.0.tgz#24a4831ecf5a6b01ddeb32fb71a4b2088b0dce38" + integrity sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw== + dependencies: + restore-cursor "^5.0.0" + +cli-spinners@^2.9.2: + version "2.9.2" + resolved "https://registry.yarnpkg.com/cli-spinners/-/cli-spinners-2.9.2.tgz#1773a8f4b9c4d6ac31563df53b3fc1d79462fe41" + integrity sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg== + +cliui@^8.0.1: + version "8.0.1" + resolved "https://registry.yarnpkg.com/cliui/-/cliui-8.0.1.tgz#0c04b075db02cbfe60dc8e6cf2f5486b1a3608aa" + integrity sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ== + dependencies: + string-width "^4.2.0" + strip-ansi "^6.0.1" + wrap-ansi "^7.0.0" + +clsx@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/clsx/-/clsx-2.1.1.tgz#eed397c9fd8bd882bfb18deab7102049a2f32999" + integrity sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA== + +collapse-white-space@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/collapse-white-space/-/collapse-white-space-2.1.0.tgz#640257174f9f42c740b40f3b55ee752924feefca" + integrity sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw== + +color-convert@^1.9.0: + version "1.9.3" + resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8" + integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg== + dependencies: + color-name "1.1.3" + +color-convert@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3" + integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== + dependencies: + color-name "~1.1.4" + +color-name@1.1.3: + version "1.1.3" + resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25" + integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw== + +color-name@^1.0.0, color-name@~1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" + integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== + +color-string@^1.9.0: + version "1.9.1" + resolved "https://registry.yarnpkg.com/color-string/-/color-string-1.9.1.tgz#4467f9146f036f855b764dfb5bf8582bf342c7a4" + integrity sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg== + dependencies: + color-name "^1.0.0" + simple-swizzle "^0.2.2" + +color@^4.2.3: + version "4.2.3" + resolved "https://registry.yarnpkg.com/color/-/color-4.2.3.tgz#d781ecb5e57224ee43ea9627560107c0e0c6463a" + integrity sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A== + dependencies: + color-convert "^2.0.1" + color-string "^1.9.0" + +comma-separated-tokens@^2.0.0: + version "2.0.3" + resolved "https://registry.yarnpkg.com/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz#4e89c9458acb61bc8fef19f4529973b2392839ee" + integrity sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg== + +commander@^12.1.0: + version "12.1.0" + resolved "https://registry.yarnpkg.com/commander/-/commander-12.1.0.tgz#01423b36f501259fdaac4d0e4d60c96c991585d3" + integrity sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA== + +commander@^8.3.0: + version "8.3.0" + resolved "https://registry.yarnpkg.com/commander/-/commander-8.3.0.tgz#4837ea1b2da67b9c616a67afbb0fafee567bca66" + integrity sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww== + +comment-json@^4.2.5: + version "4.2.5" + resolved "https://registry.yarnpkg.com/comment-json/-/comment-json-4.2.5.tgz#482e085f759c2704b60bc6f97f55b8c01bc41e70" + integrity sha512-bKw/r35jR3HGt5PEPm1ljsQQGyCrR8sFGNiN5L+ykDHdpO8Smxkrkla9Yi6NkQyUrb8V54PGhfMs6NrIwtxtdw== + dependencies: + array-timsort "^1.0.3" + core-util-is "^1.0.3" + esprima "^4.0.1" + has-own-prop "^2.0.0" + repeat-string "^1.6.1" + +common-ancestor-path@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/common-ancestor-path/-/common-ancestor-path-1.0.1.tgz#4f7d2d1394d91b7abdf51871c62f71eadb0182a7" + integrity sha512-L3sHRo1pXXEqX8VU28kfgUY+YGsk09hPqZiZmLacNib6XNTCM8ubYeT7ryXQw8asB1sKgcU5lkB7ONug08aB8w== + +convert-source-map@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-2.0.0.tgz#4b560f649fc4e918dd0ab75cf4961e8bc882d82a" + integrity sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg== + +cookie@^0.6.0: + version "0.6.0" + resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.6.0.tgz#2798b04b071b0ecbff0dbb62a505a8efa4e19051" + integrity sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw== + +core-util-is@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85" + integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ== + +cspell-config-lib@8.14.4: + version "8.14.4" + resolved "https://registry.yarnpkg.com/cspell-config-lib/-/cspell-config-lib-8.14.4.tgz#4642d22c4db22dd1b8923005ff369a24ff541f62" + integrity sha512-cnUeJfniTiebqCaQmIUnbSrPrTH7xzKRQjJDHAEV0WYnOG2MhRXI13OzytdFdhkVBdStmgTzTCJKE7x+kmU2NA== + dependencies: + "@cspell/cspell-types" "8.14.4" + comment-json "^4.2.5" + yaml "^2.5.1" + +cspell-dictionary@8.14.4: + version "8.14.4" + resolved "https://registry.yarnpkg.com/cspell-dictionary/-/cspell-dictionary-8.14.4.tgz#d6bfaa972785b184499d7f81791c913440229de4" + integrity sha512-pZvQHxpAW5fZAnt3ZKKy3s7M+3CX2t8tCS3uJrpEHIynlCawpG0fPF78rVE5o+g0dON36Lguc/BUuSN4IWKLmQ== + dependencies: + "@cspell/cspell-pipe" "8.14.4" + "@cspell/cspell-types" "8.14.4" + cspell-trie-lib "8.14.4" + fast-equals "^5.0.1" + +cspell-gitignore@8.14.4: + version "8.14.4" + resolved "https://registry.yarnpkg.com/cspell-gitignore/-/cspell-gitignore-8.14.4.tgz#bb53748ed93af980ed7c5772577ccdedada85293" + integrity sha512-RwfQEW5hD7CpYwS7m3b0ONG0nTLKP6bL2tvMdl7qtaYkL7ztGdsBTtLD1pmwqUsCbiN5RuaOxhYOYeRcpFRIkQ== + dependencies: + "@cspell/url" "8.14.4" + cspell-glob "8.14.4" + cspell-io "8.14.4" + find-up-simple "^1.0.0" + +cspell-glob@8.14.4: + version "8.14.4" + resolved "https://registry.yarnpkg.com/cspell-glob/-/cspell-glob-8.14.4.tgz#b5abbaa291f3d17d5e52a33d26193a29761e30c8" + integrity sha512-C/xTS5nujMRMuguibq92qMVP767mtxrur7DcVolCvpzcivm1RB5NtIN0OctQxTyMbnmKeQv1t4epRKQ9A8vWRg== + dependencies: + "@cspell/url" "8.14.4" + micromatch "^4.0.8" + +cspell-grammar@8.14.4: + version "8.14.4" + resolved "https://registry.yarnpkg.com/cspell-grammar/-/cspell-grammar-8.14.4.tgz#a047c9d365127f9e7688eebb649b14a8a7b0ce9e" + integrity sha512-yaSKAAJDiamsw3FChbw4HXb2RvTQrDsLelh1+T4MavarOIcAxXrqAJ8ysqm++g+S/ooJz2YO8YWIyzJKxcMf8g== + dependencies: + "@cspell/cspell-pipe" "8.14.4" + "@cspell/cspell-types" "8.14.4" + +cspell-io@8.14.4: + version "8.14.4" + resolved "https://registry.yarnpkg.com/cspell-io/-/cspell-io-8.14.4.tgz#fa80333f473fd04973b850c25116b6392f6c88a3" + integrity sha512-o6OTWRyx/Az+PFhr1B0wMAwqG070hFC9g73Fkxd8+rHX0rfRS69QZH7LgSmZytqbZIMxCTDGdsLl33MFGWCbZQ== + dependencies: + "@cspell/cspell-service-bus" "8.14.4" + "@cspell/url" "8.14.4" + +cspell-lib@8.14.4: + version "8.14.4" + resolved "https://registry.yarnpkg.com/cspell-lib/-/cspell-lib-8.14.4.tgz#f59f3141c3b9b44b46defc927365e484a1f7d1cc" + integrity sha512-qdkUkKtm+nmgpA4jQbmQTuepDfjHBDWvs3zDuEwVIVFq/h8gnXrRr75gJ3RYdTy+vOOqHPoLLqgxyqkUUrUGXA== + dependencies: + "@cspell/cspell-bundled-dicts" "8.14.4" + "@cspell/cspell-pipe" "8.14.4" + "@cspell/cspell-resolver" "8.14.4" + "@cspell/cspell-types" "8.14.4" + "@cspell/dynamic-import" "8.14.4" + "@cspell/filetypes" "8.14.4" + "@cspell/strong-weak-map" "8.14.4" + "@cspell/url" "8.14.4" + clear-module "^4.1.2" + comment-json "^4.2.5" + cspell-config-lib "8.14.4" + cspell-dictionary "8.14.4" + cspell-glob "8.14.4" + cspell-grammar "8.14.4" + cspell-io "8.14.4" + cspell-trie-lib "8.14.4" + env-paths "^3.0.0" + fast-equals "^5.0.1" + gensequence "^7.0.0" + import-fresh "^3.3.0" + resolve-from "^5.0.0" + vscode-languageserver-textdocument "^1.0.12" + vscode-uri "^3.0.8" + xdg-basedir "^5.1.0" + +cspell-trie-lib@8.14.4: + version "8.14.4" + resolved "https://registry.yarnpkg.com/cspell-trie-lib/-/cspell-trie-lib-8.14.4.tgz#1cc1d1110edc0d208a027b1bdc3cbec1a15ea7f8" + integrity sha512-zu8EJ33CH+FA5lwTRGqS//Q6phO0qtgEmODMR1KPlD7WlrfTFMb3bWFsLo/tiv5hjpsn7CM6dYDAAgBOSkoyhQ== + dependencies: + "@cspell/cspell-pipe" "8.14.4" + "@cspell/cspell-types" "8.14.4" + gensequence "^7.0.0" + +cspell@^8.14.4: + version "8.14.4" + resolved "https://registry.yarnpkg.com/cspell/-/cspell-8.14.4.tgz#a160fefcaf7158b8fa435245936b4f0426dc8736" + integrity sha512-R5Awb3i/RKaVVcZzFt8dkN3M6VnifIEDYBcbzbmYjZ/Eq+ASF+QTmI0E9WPhMEcFM1nd7YOyXnETo560yRdoKw== + dependencies: + "@cspell/cspell-json-reporter" "8.14.4" + "@cspell/cspell-pipe" "8.14.4" + "@cspell/cspell-types" "8.14.4" + "@cspell/dynamic-import" "8.14.4" + "@cspell/url" "8.14.4" + chalk "^5.3.0" + chalk-template "^1.1.0" + commander "^12.1.0" + cspell-dictionary "8.14.4" + cspell-gitignore "8.14.4" + cspell-glob "8.14.4" + cspell-io "8.14.4" + cspell-lib "8.14.4" + fast-glob "^3.3.2" + fast-json-stable-stringify "^2.1.0" + file-entry-cache "^9.1.0" + get-stdin "^9.0.0" + semver "^7.6.3" + strip-ansi "^7.1.0" + +css-selector-parser@^3.0.0: + version "3.0.5" + resolved "https://registry.yarnpkg.com/css-selector-parser/-/css-selector-parser-3.0.5.tgz#9b636ebccf7c4bcce5c1ac21ae27de9f01180ae9" + integrity sha512-3itoDFbKUNx1eKmVpYMFyqKX04Ww9osZ+dLgrk6GEv6KMVeXUhUnp4I5X+evw+u3ZxVU6RFXSSRxlTeMh8bA+g== + +cssesc@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/cssesc/-/cssesc-3.0.0.tgz#37741919903b868565e1c09ea747445cd18983ee" + integrity sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg== + +debug@^4.0.0, debug@^4.1.0, debug@^4.3.1, debug@^4.3.4, debug@^4.3.7: + version "4.3.7" + resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.7.tgz#87945b4151a011d76d95a198d7111c865c360a52" + integrity sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ== + dependencies: + ms "^2.1.3" + +decode-named-character-reference@^1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/decode-named-character-reference/-/decode-named-character-reference-1.0.2.tgz#daabac9690874c394c81e4162a0304b35d824f0e" + integrity sha512-O8x12RzrUF8xyVcY0KJowWsmaJxQbmy0/EtnNtHRpsOcT7dFk5W598coHqBVpmWo1oQQfsCqfCmkZN5DJrZVdg== + dependencies: + character-entities "^2.0.0" + +decompress-response@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/decompress-response/-/decompress-response-6.0.0.tgz#ca387612ddb7e104bd16d85aab00d5ecf09c66fc" + integrity sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ== + dependencies: + mimic-response "^3.1.0" + +deep-extend@^0.6.0: + version "0.6.0" + resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac" + integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA== + +dequal@^2.0.0: + version "2.0.3" + resolved "https://registry.yarnpkg.com/dequal/-/dequal-2.0.3.tgz#2644214f1997d39ed0ee0ece72335490a7ac67be" + integrity sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA== + +detect-libc@^2.0.0, detect-libc@^2.0.2, detect-libc@^2.0.3: + version "2.0.3" + resolved "https://registry.yarnpkg.com/detect-libc/-/detect-libc-2.0.3.tgz#f0cd503b40f9939b894697d19ad50895e30cf700" + integrity sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw== + +deterministic-object-hash@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/deterministic-object-hash/-/deterministic-object-hash-2.0.2.tgz#b251ddc801443905f0e9fef08816a46bc9fe3807" + integrity sha512-KxektNH63SrbfUyDiwXqRb1rLwKt33AmMv+5Nhsw1kqZ13SJBRTgZHtGbE+hH3a1mVW1cz+4pqSWVPAtLVXTzQ== + dependencies: + base-64 "^1.0.0" + +devalue@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/devalue/-/devalue-5.0.0.tgz#1ca0099a7d715b4d6cac3924e770ccbbc584ad98" + integrity sha512-gO+/OMXF7488D+u3ue+G7Y4AA3ZmUnB3eHJXmBTgNHvr4ZNzl36A0ZtG+XCRNYCkYx/bFmw4qtkoFLa+wSrwAA== + +devlop@^1.0.0, devlop@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/devlop/-/devlop-1.1.0.tgz#4db7c2ca4dc6e0e834c30be70c94bbc976dc7018" + integrity sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA== + dependencies: + dequal "^2.0.0" + +diff@^5.2.0: + version "5.2.0" + resolved "https://registry.yarnpkg.com/diff/-/diff-5.2.0.tgz#26ded047cd1179b78b9537d5ef725503ce1ae531" + integrity sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A== + +direction@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/direction/-/direction-2.0.1.tgz#71800dd3c4fa102406502905d3866e65bdebb985" + integrity sha512-9S6m9Sukh1cZNknO1CWAr2QAWsbKLafQiyM5gZ7VgXHeuaoUwffKN4q6NC4A/Mf9iiPlOXQEKW/Mv/mh9/3YFA== + +dlv@^1.1.3: + version "1.1.3" + resolved "https://registry.yarnpkg.com/dlv/-/dlv-1.1.3.tgz#5c198a8a11453596e751494d49874bc7732f2e79" + integrity sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA== + +dset@^3.1.3: + version "3.1.4" + resolved "https://registry.yarnpkg.com/dset/-/dset-3.1.4.tgz#f8eaf5f023f068a036d08cd07dc9ffb7d0065248" + integrity sha512-2QF/g9/zTaPDc3BjNcVTGoBbXBgYfMTTceLaYcFJ/W9kggFUkhxD/hMEeuLKbugyef9SqAx8cpgwlIP/jinUTA== + +eastasianwidth@^0.2.0: + version "0.2.0" + resolved "https://registry.yarnpkg.com/eastasianwidth/-/eastasianwidth-0.2.0.tgz#696ce2ec0aa0e6ea93a397ffcf24aa7840c827cb" + integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA== + +electron-to-chromium@^1.5.4: + version "1.5.25" + resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.5.25.tgz#492ade1cde401332b9b75aa0c55fd5e1550ca66c" + integrity sha512-kMb204zvK3PsSlgvvwzI3wBIcAw15tRkYk+NQdsjdDtcQWTp2RABbMQ9rUBy8KNEOM+/E6ep+XC3AykiWZld4g== + +emmet@^2.4.3: + version "2.4.8" + resolved "https://registry.yarnpkg.com/emmet/-/emmet-2.4.8.tgz#b41ab09acfc19e226a9f3a367c487c0df55075ca" + integrity sha512-wFe/dxsx7oi/M2UJ/3yBu4Fm24Irho6lqut4C1YFaZebCvCCMygoDGC7W6I+8+K8PAjfa/Ojn52UHi8WCdDiRA== + dependencies: + "@emmetio/abbreviation" "^2.3.3" + "@emmetio/css-abbreviation" "^2.1.8" + +emoji-regex@^10.3.0: + version "10.4.0" + resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-10.4.0.tgz#03553afea80b3975749cfcb36f776ca268e413d4" + integrity sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw== + +emoji-regex@^8.0.0: + version "8.0.0" + resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" + integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== + +emoji-regex@^9.2.2: + version "9.2.2" + resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72" + integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg== + +end-of-stream@^1.1.0, end-of-stream@^1.4.1: + version "1.4.4" + resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0" + integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q== + dependencies: + once "^1.4.0" + +entities@^4.4.0: + version "4.5.0" + resolved "https://registry.yarnpkg.com/entities/-/entities-4.5.0.tgz#5d268ea5e7113ec74c4d033b79ea5a35a488fb48" + integrity sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw== + +env-paths@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/env-paths/-/env-paths-3.0.0.tgz#2f1e89c2f6dbd3408e1b1711dd82d62e317f58da" + integrity sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A== + +es-module-lexer@^1.5.4: + version "1.5.4" + resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-1.5.4.tgz#a8efec3a3da991e60efa6b633a7cad6ab8d26b78" + integrity sha512-MVNK56NiMrOwitFB7cqDwq0CQutbw+0BvLshJSse0MUNU+y1FC3bUS/AQg7oUng+/wKrrki7JfmwtVHkVfPLlw== + +esbuild@^0.21.3, esbuild@^0.21.5: + version "0.21.5" + resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.21.5.tgz#9ca301b120922959b766360d8ac830da0d02997d" + integrity sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw== + optionalDependencies: + "@esbuild/aix-ppc64" "0.21.5" + "@esbuild/android-arm" "0.21.5" + "@esbuild/android-arm64" "0.21.5" + "@esbuild/android-x64" "0.21.5" + "@esbuild/darwin-arm64" "0.21.5" + "@esbuild/darwin-x64" "0.21.5" + "@esbuild/freebsd-arm64" "0.21.5" + "@esbuild/freebsd-x64" "0.21.5" + "@esbuild/linux-arm" "0.21.5" + "@esbuild/linux-arm64" "0.21.5" + "@esbuild/linux-ia32" "0.21.5" + "@esbuild/linux-loong64" "0.21.5" + "@esbuild/linux-mips64el" "0.21.5" + "@esbuild/linux-ppc64" "0.21.5" + "@esbuild/linux-riscv64" "0.21.5" + "@esbuild/linux-s390x" "0.21.5" + "@esbuild/linux-x64" "0.21.5" + "@esbuild/netbsd-x64" "0.21.5" + "@esbuild/openbsd-x64" "0.21.5" + "@esbuild/sunos-x64" "0.21.5" + "@esbuild/win32-arm64" "0.21.5" + "@esbuild/win32-ia32" "0.21.5" + "@esbuild/win32-x64" "0.21.5" + +escalade@^3.1.1, escalade@^3.1.2: + version "3.2.0" + resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.2.0.tgz#011a3f69856ba189dffa7dc8fcce99d2a87903e5" + integrity sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA== + +escape-string-regexp@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4" + integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg== + +escape-string-regexp@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz#4683126b500b61762f2dbebace1806e8be31b1c8" + integrity sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw== + +esprima@^4.0.0, esprima@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71" + integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== + +estree-util-attach-comments@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/estree-util-attach-comments/-/estree-util-attach-comments-3.0.0.tgz#344bde6a64c8a31d15231e5ee9e297566a691c2d" + integrity sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw== + dependencies: + "@types/estree" "^1.0.0" + +estree-util-build-jsx@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/estree-util-build-jsx/-/estree-util-build-jsx-3.0.1.tgz#b6d0bced1dcc4f06f25cf0ceda2b2dcaf98168f1" + integrity sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ== + dependencies: + "@types/estree-jsx" "^1.0.0" + devlop "^1.0.0" + estree-util-is-identifier-name "^3.0.0" + estree-walker "^3.0.0" + +estree-util-is-identifier-name@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz#0b5ef4c4ff13508b34dcd01ecfa945f61fce5dbd" + integrity sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg== + +estree-util-to-js@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/estree-util-to-js/-/estree-util-to-js-2.0.0.tgz#10a6fb924814e6abb62becf0d2bc4dea51d04f17" + integrity sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg== + dependencies: + "@types/estree-jsx" "^1.0.0" + astring "^1.8.0" + source-map "^0.7.0" + +estree-util-visit@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/estree-util-visit/-/estree-util-visit-2.0.0.tgz#13a9a9f40ff50ed0c022f831ddf4b58d05446feb" + integrity sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww== + dependencies: + "@types/estree-jsx" "^1.0.0" + "@types/unist" "^3.0.0" + +estree-walker@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-2.0.2.tgz#52f010178c2a4c117a7757cfe942adb7d2da4cac" + integrity sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w== + +estree-walker@^3.0.0, estree-walker@^3.0.3: + version "3.0.3" + resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-3.0.3.tgz#67c3e549ec402a487b4fc193d1953a524752340d" + integrity sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g== + dependencies: + "@types/estree" "^1.0.0" + +eventemitter3@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-5.0.1.tgz#53f5ffd0a492ac800721bb42c66b841de96423c4" + integrity sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA== + +expand-template@^2.0.3: + version "2.0.3" + resolved "https://registry.yarnpkg.com/expand-template/-/expand-template-2.0.3.tgz#6e14b3fcee0f3a6340ecb57d2e8918692052a47c" + integrity sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg== + +expressive-code@^0.35.6: + version "0.35.6" + resolved "https://registry.yarnpkg.com/expressive-code/-/expressive-code-0.35.6.tgz#ad8ee87bd5d5376c07a5f4475bbf98366b5b307a" + integrity sha512-+mx+TPTbMqgo0mL92Xh9QgjW0kSQIsEivMgEcOnaqKqL7qCw8Vkqc5Rg/di7ZYw4aMUSr74VTc+w8GQWu05j1g== + dependencies: + "@expressive-code/core" "^0.35.6" + "@expressive-code/plugin-frames" "^0.35.6" + "@expressive-code/plugin-shiki" "^0.35.6" + "@expressive-code/plugin-text-markers" "^0.35.6" + +extend-shallow@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f" + integrity sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug== + dependencies: + is-extendable "^0.1.0" + +extend@^3.0.0: + version "3.0.2" + resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa" + integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g== + +fast-deep-equal@^3.1.3: + version "3.1.3" + resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" + integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== + +fast-equals@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/fast-equals/-/fast-equals-5.0.1.tgz#a4eefe3c5d1c0d021aeed0bc10ba5e0c12ee405d" + integrity sha512-WF1Wi8PwwSY7/6Kx0vKXtw8RwuSGoM1bvDaJbu7MxDlR1vovZjIAKrnzyrThgAjm6JDTu0fVgWXDlMGspodfoQ== + +fast-fifo@^1.2.0, fast-fifo@^1.3.2: + version "1.3.2" + resolved "https://registry.yarnpkg.com/fast-fifo/-/fast-fifo-1.3.2.tgz#286e31de96eb96d38a97899815740ba2a4f3640c" + integrity sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ== + +fast-glob@^3.2.12, fast-glob@^3.3.1, fast-glob@^3.3.2: + version "3.3.2" + resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.3.2.tgz#a904501e57cfdd2ffcded45e99a54fef55e46129" + integrity sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow== + dependencies: + "@nodelib/fs.stat" "^2.0.2" + "@nodelib/fs.walk" "^1.2.3" + glob-parent "^5.1.2" + merge2 "^1.3.0" + micromatch "^4.0.4" + +fast-json-stable-stringify@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633" + integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== + +fast-uri@^3.0.1: + version "3.0.1" + resolved "https://registry.yarnpkg.com/fast-uri/-/fast-uri-3.0.1.tgz#cddd2eecfc83a71c1be2cc2ef2061331be8a7134" + integrity sha512-MWipKbbYiYI0UC7cl8m/i/IWTqfC8YXsqjzybjddLsFjStroQzsHXkc73JutMvBiXmOvapk+axIl79ig5t55Bw== + +fastq@^1.17.1, fastq@^1.6.0: + version "1.17.1" + resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.17.1.tgz#2a523f07a4e7b1e81a42b91b8bf2254107753b47" + integrity sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w== + dependencies: + reusify "^1.0.4" + +file-entry-cache@^9.1.0: + version "9.1.0" + resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-9.1.0.tgz#2e66ad98ce93f49aed1b178c57b0b5741591e075" + integrity sha512-/pqPFG+FdxWQj+/WSuzXSDaNzxgTLr/OrR1QuqfEZzDakpdYE70PwUxL7BPUa8hpjbvY1+qvCl8k+8Tq34xJgg== + dependencies: + flat-cache "^5.0.0" + +fill-range@^7.1.1: + version "7.1.1" + resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.1.1.tgz#44265d3cac07e3ea7dc247516380643754a05292" + integrity sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg== + dependencies: + to-regex-range "^5.0.1" + +find-up-simple@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/find-up-simple/-/find-up-simple-1.0.0.tgz#21d035fde9fdbd56c8f4d2f63f32fd93a1cfc368" + integrity sha512-q7Us7kcjj2VMePAa02hDAF6d+MzsdsAWEwYyOpwUtlerRBkOEPBCRZrAV4XfcSN8fHAgaD0hP7miwoay6DCprw== + +find-up@^4.0.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19" + integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw== + dependencies: + locate-path "^5.0.0" + path-exists "^4.0.0" + +find-yarn-workspace-root2@1.2.16: + version "1.2.16" + resolved "https://registry.yarnpkg.com/find-yarn-workspace-root2/-/find-yarn-workspace-root2-1.2.16.tgz#60287009dd2f324f59646bdb4b7610a6b301c2a9" + integrity sha512-hr6hb1w8ePMpPVUK39S4RlwJzi+xPLuVuG8XlwXU3KD5Yn3qgBWVfy3AzNlDhWvE1EORCE65/Qm26rFQt3VLVA== + dependencies: + micromatch "^4.0.2" + pkg-dir "^4.2.0" + +flat-cache@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-5.0.0.tgz#26c4da7b0f288b408bb2b506b2cb66c240ddf062" + integrity sha512-JrqFmyUl2PnPi1OvLyTVHnQvwQ0S+e6lGSwu8OkAZlSaNIZciTY2H/cOOROxsBA1m/LZNHDsqAgDZt6akWcjsQ== + dependencies: + flatted "^3.3.1" + keyv "^4.5.4" + +flatted@^3.3.1: + version "3.3.1" + resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.3.1.tgz#21db470729a6734d4997002f439cb308987f567a" + integrity sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw== + +flattie@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/flattie/-/flattie-1.1.1.tgz#88182235723113667d36217fec55359275d6fe3d" + integrity sha512-9UbaD6XdAL97+k/n+N7JwX46K/M6Zc6KcFYskrYL8wbBV/Uyk0CTAMY0VT+qiK5PM7AIc9aTWYtq65U7T+aCNQ== + +fs-constants@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/fs-constants/-/fs-constants-1.0.0.tgz#6be0de9be998ce16af8afc24497b9ee9b7ccd9ad" + integrity sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow== + +fsevents@~2.3.2, fsevents@~2.3.3: + version "2.3.3" + resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6" + integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw== + +gensequence@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/gensequence/-/gensequence-7.0.0.tgz#bb6aedec8ff665e3a6c42f92823121e3a6ea7718" + integrity sha512-47Frx13aZh01afHJTB3zTtKIlFI6vWY+MYCN9Qpew6i52rfKjnhCF/l1YlC8UmEMvvntZZ6z4PiCcmyuedR2aQ== + +gensync@^1.0.0-beta.2: + version "1.0.0-beta.2" + resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0" + integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg== + +get-caller-file@^2.0.5: + version "2.0.5" + resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e" + integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== + +get-east-asian-width@^1.0.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/get-east-asian-width/-/get-east-asian-width-1.2.0.tgz#5e6ebd9baee6fb8b7b6bd505221065f0cd91f64e" + integrity sha512-2nk+7SIVb14QrgXFHcm84tD4bKQz0RxPuMT8Ag5KPOq7J5fEmAg0UbXdTOSHqNuHSU28k55qnceesxXRZGzKWA== + +get-stdin@^9.0.0: + version "9.0.0" + resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-9.0.0.tgz#3983ff82e03d56f1b2ea0d3e60325f39d703a575" + integrity sha512-dVKBjfWisLAicarI2Sf+JuBE/DghV4UzNAVe9yhEJuzeREd3JhOTE9cUaJTeSa77fsbQUK3pcOpJfM59+VKZaA== + +github-from-package@0.0.0: + version "0.0.0" + resolved "https://registry.yarnpkg.com/github-from-package/-/github-from-package-0.0.0.tgz#97fb5d96bfde8973313f20e8288ef9a167fa64ce" + integrity sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw== + +github-slugger@2.0.0, github-slugger@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/github-slugger/-/github-slugger-2.0.0.tgz#52cf2f9279a21eb6c59dd385b410f0c0adda8f1a" + integrity sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw== + +glob-parent@^5.1.2, glob-parent@~5.1.2: + version "5.1.2" + resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4" + integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== + dependencies: + is-glob "^4.0.1" + +global-directory@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/global-directory/-/global-directory-4.0.1.tgz#4d7ac7cfd2cb73f304c53b8810891748df5e361e" + integrity sha512-wHTUcDUoZ1H5/0iVqEudYW4/kAlN5cZ3j/bXn0Dpbizl9iaUVeWSHqiOjsgk6OW2bkLclbBjzewBz6weQ1zA2Q== + dependencies: + ini "4.1.1" + +globals@^11.1.0: + version "11.12.0" + resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e" + integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== + +graceful-fs@^4.1.5: + version "4.2.11" + resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3" + integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== + +gray-matter@^4.0.3: + version "4.0.3" + resolved "https://registry.yarnpkg.com/gray-matter/-/gray-matter-4.0.3.tgz#e893c064825de73ea1f5f7d88c7a9f7274288798" + integrity sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q== + dependencies: + js-yaml "^3.13.1" + kind-of "^6.0.2" + section-matter "^1.0.0" + strip-bom-string "^1.0.0" + +has-flag@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd" + integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw== + +has-own-prop@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/has-own-prop/-/has-own-prop-2.0.0.tgz#f0f95d58f65804f5d218db32563bb85b8e0417af" + integrity sha512-Pq0h+hvsVm6dDEa8x82GnLSYHOzNDt7f0ddFa3FqcQlgzEiptPqL+XrOJNavjOzSYiYWIrgeVYYgGlLmnxwilQ== + +hast-util-embedded@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/hast-util-embedded/-/hast-util-embedded-3.0.0.tgz#be4477780fbbe079cdba22982e357a0de4ba853e" + integrity sha512-naH8sld4Pe2ep03qqULEtvYr7EjrLK2QHY8KJR6RJkTUjPGObe1vnx585uzem2hGra+s1q08DZZpfgDVYRbaXA== + dependencies: + "@types/hast" "^3.0.0" + hast-util-is-element "^3.0.0" + +hast-util-format@^1.0.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/hast-util-format/-/hast-util-format-1.1.0.tgz#373e77382e07deb04f6676f1b4437e7d8549d985" + integrity sha512-yY1UDz6bC9rDvCWHpx12aIBGRG7krurX0p0Fm6pT547LwDIZZiNr8a+IHDogorAdreULSEzP82Nlv5SZkHZcjA== + dependencies: + "@types/hast" "^3.0.0" + hast-util-embedded "^3.0.0" + hast-util-minify-whitespace "^1.0.0" + hast-util-phrasing "^3.0.0" + hast-util-whitespace "^3.0.0" + html-whitespace-sensitive-tag-names "^3.0.0" + unist-util-visit-parents "^6.0.0" + +hast-util-from-dom@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/hast-util-from-dom/-/hast-util-from-dom-5.0.0.tgz#d32edd25bf28f4b178b5ae318f8d05762e67bd16" + integrity sha512-d6235voAp/XR3Hh5uy7aGLbM3S4KamdW0WEgOaU1YoewnuYw4HXb5eRtv9g65m/RFGEfUY1Mw4UqCc5Y8L4Stg== + dependencies: + "@types/hast" "^3.0.0" + hastscript "^8.0.0" + web-namespaces "^2.0.0" + +hast-util-from-html-isomorphic@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/hast-util-from-html-isomorphic/-/hast-util-from-html-isomorphic-2.0.0.tgz#b31baee386a899a2472326a3c5692f29f86d1d3c" + integrity sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw== + dependencies: + "@types/hast" "^3.0.0" + hast-util-from-dom "^5.0.0" + hast-util-from-html "^2.0.0" + unist-util-remove-position "^5.0.0" + +hast-util-from-html@2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/hast-util-from-html/-/hast-util-from-html-2.0.1.tgz#9cd38ee81bf40b2607368b92a04b0905fa987488" + integrity sha512-RXQBLMl9kjKVNkJTIO6bZyb2n+cUH8LFaSSzo82jiLT6Tfc+Pt7VQCS+/h3YwG4jaNE2TA2sdJisGWR+aJrp0g== + dependencies: + "@types/hast" "^3.0.0" + devlop "^1.1.0" + hast-util-from-parse5 "^8.0.0" + parse5 "^7.0.0" + vfile "^6.0.0" + vfile-message "^4.0.0" + +hast-util-from-html@^2.0.0, hast-util-from-html@^2.0.1: + version "2.0.3" + resolved "https://registry.yarnpkg.com/hast-util-from-html/-/hast-util-from-html-2.0.3.tgz#485c74785358beb80c4ba6346299311ac4c49c82" + integrity sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw== + dependencies: + "@types/hast" "^3.0.0" + devlop "^1.1.0" + hast-util-from-parse5 "^8.0.0" + parse5 "^7.0.0" + vfile "^6.0.0" + vfile-message "^4.0.0" + +hast-util-from-parse5@^8.0.0: + version "8.0.1" + resolved "https://registry.yarnpkg.com/hast-util-from-parse5/-/hast-util-from-parse5-8.0.1.tgz#654a5676a41211e14ee80d1b1758c399a0327651" + integrity sha512-Er/Iixbc7IEa7r/XLtuG52zoqn/b3Xng/w6aZQ0xGVxzhw5xUFxcRqdPzP6yFi/4HBYRaifaI5fQ1RH8n0ZeOQ== + dependencies: + "@types/hast" "^3.0.0" + "@types/unist" "^3.0.0" + devlop "^1.0.0" + hastscript "^8.0.0" + property-information "^6.0.0" + vfile "^6.0.0" + vfile-location "^5.0.0" + web-namespaces "^2.0.0" + +hast-util-has-property@3.0.0, hast-util-has-property@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/hast-util-has-property/-/hast-util-has-property-3.0.0.tgz#4e595e3cddb8ce530ea92f6fc4111a818d8e7f93" + integrity sha512-MNilsvEKLFpV604hwfhVStK0usFY/QmM5zX16bo7EjnAEGofr5YyI37kzopBlZJkHD4t887i+q/C8/tr5Q94cA== + dependencies: + "@types/hast" "^3.0.0" + +hast-util-heading-rank@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/hast-util-heading-rank/-/hast-util-heading-rank-3.0.0.tgz#2d5c6f2807a7af5c45f74e623498dd6054d2aba8" + integrity sha512-EJKb8oMUXVHcWZTDepnr+WNbfnXKFNf9duMesmr4S8SXTJBJ9M4Yok08pu9vxdJwdlGRhVumk9mEhkEvKGifwA== + dependencies: + "@types/hast" "^3.0.0" + +hast-util-is-body-ok-link@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/hast-util-is-body-ok-link/-/hast-util-is-body-ok-link-3.0.0.tgz#6b2d808813a6f73eb20e61bdd2b203591af85eb4" + integrity sha512-VFHY5bo2nY8HiV6nir2ynmEB1XkxzuUffhEGeVx7orbu/B1KaGyeGgMZldvMVx5xWrDlLLG/kQ6YkJAMkBEx0w== + dependencies: + "@types/hast" "^3.0.0" + +hast-util-is-element@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/hast-util-is-element/-/hast-util-is-element-3.0.0.tgz#6e31a6532c217e5b533848c7e52c9d9369ca0932" + integrity sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g== + dependencies: + "@types/hast" "^3.0.0" + +hast-util-minify-whitespace@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/hast-util-minify-whitespace/-/hast-util-minify-whitespace-1.0.0.tgz#e3170d521beea2a4e7fc4b35987c8aa6c49a0925" + integrity sha512-gD1m4YJSIk62ij32TlhFNqsC3dOQvpA4QAhyZOZFAT4u8LfEfB6N+F0V9oXQGBWXoqrs0h9wQRKa8RCeo8j61g== + dependencies: + "@types/hast" "^3.0.0" + hast-util-embedded "^3.0.0" + hast-util-is-element "^3.0.0" + hast-util-whitespace "^3.0.0" + unist-util-is "^6.0.0" + +hast-util-parse-selector@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz#352879fa86e25616036037dd8931fb5f34cb4a27" + integrity sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A== + dependencies: + "@types/hast" "^3.0.0" + +hast-util-phrasing@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/hast-util-phrasing/-/hast-util-phrasing-3.0.1.tgz#fa284c0cd4a82a0dd6020de8300a7b1ebffa1690" + integrity sha512-6h60VfI3uBQUxHqTyMymMZnEbNl1XmEGtOxxKYL7stY2o601COo62AWAYBQR9lZbYXYSBoxag8UpPRXK+9fqSQ== + dependencies: + "@types/hast" "^3.0.0" + hast-util-embedded "^3.0.0" + hast-util-has-property "^3.0.0" + hast-util-is-body-ok-link "^3.0.0" + hast-util-is-element "^3.0.0" + +hast-util-raw@^9.0.0: + version "9.0.4" + resolved "https://registry.yarnpkg.com/hast-util-raw/-/hast-util-raw-9.0.4.tgz#2da03e37c46eb1a6f1391f02f9b84ae65818f7ed" + integrity sha512-LHE65TD2YiNsHD3YuXcKPHXPLuYh/gjp12mOfU8jxSrm1f/yJpsb0F/KKljS6U9LJoP0Ux+tCe8iJ2AsPzTdgA== + dependencies: + "@types/hast" "^3.0.0" + "@types/unist" "^3.0.0" + "@ungap/structured-clone" "^1.0.0" + hast-util-from-parse5 "^8.0.0" + hast-util-to-parse5 "^8.0.0" + html-void-elements "^3.0.0" + mdast-util-to-hast "^13.0.0" + parse5 "^7.0.0" + unist-util-position "^5.0.0" + unist-util-visit "^5.0.0" + vfile "^6.0.0" + web-namespaces "^2.0.0" + zwitch "^2.0.0" + +hast-util-select@^6.0.2: + version "6.0.2" + resolved "https://registry.yarnpkg.com/hast-util-select/-/hast-util-select-6.0.2.tgz#f1e6c583ab6227cb510383471328734342bd1d1c" + integrity sha512-hT/SD/d/Meu+iobvgkffo1QecV8WeKWxwsNMzcTJsKw1cKTQKSR/7ArJeURLNJF9HDjp9nVoORyNNJxrvBye8Q== + dependencies: + "@types/hast" "^3.0.0" + "@types/unist" "^3.0.0" + bcp-47-match "^2.0.0" + comma-separated-tokens "^2.0.0" + css-selector-parser "^3.0.0" + devlop "^1.0.0" + direction "^2.0.0" + hast-util-has-property "^3.0.0" + hast-util-to-string "^3.0.0" + hast-util-whitespace "^3.0.0" + not "^0.1.0" + nth-check "^2.0.0" + property-information "^6.0.0" + space-separated-tokens "^2.0.0" + unist-util-visit "^5.0.0" + zwitch "^2.0.0" + +hast-util-to-estree@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/hast-util-to-estree/-/hast-util-to-estree-3.1.0.tgz#f2afe5e869ddf0cf690c75f9fc699f3180b51b19" + integrity sha512-lfX5g6hqVh9kjS/B9E2gSkvHH4SZNiQFiqWS0x9fENzEl+8W12RqdRxX6d/Cwxi30tPQs3bIO+aolQJNp1bIyw== + dependencies: + "@types/estree" "^1.0.0" + "@types/estree-jsx" "^1.0.0" + "@types/hast" "^3.0.0" + comma-separated-tokens "^2.0.0" + devlop "^1.0.0" + estree-util-attach-comments "^3.0.0" + estree-util-is-identifier-name "^3.0.0" + hast-util-whitespace "^3.0.0" + mdast-util-mdx-expression "^2.0.0" + mdast-util-mdx-jsx "^3.0.0" + mdast-util-mdxjs-esm "^2.0.0" + property-information "^6.0.0" + space-separated-tokens "^2.0.0" + style-to-object "^0.4.0" + unist-util-position "^5.0.0" + zwitch "^2.0.0" + +hast-util-to-html@^9.0.0, hast-util-to-html@^9.0.1, hast-util-to-html@^9.0.2, hast-util-to-html@^9.0.3: + version "9.0.3" + resolved "https://registry.yarnpkg.com/hast-util-to-html/-/hast-util-to-html-9.0.3.tgz#a9999a0ba6b4919576a9105129fead85d37f302b" + integrity sha512-M17uBDzMJ9RPCqLMO92gNNUDuBSq10a25SDBI08iCCxmorf4Yy6sYHK57n9WAbRAAaU+DuR4W6GN9K4DFZesYg== + dependencies: + "@types/hast" "^3.0.0" + "@types/unist" "^3.0.0" + ccount "^2.0.0" + comma-separated-tokens "^2.0.0" + hast-util-whitespace "^3.0.0" + html-void-elements "^3.0.0" + mdast-util-to-hast "^13.0.0" + property-information "^6.0.0" + space-separated-tokens "^2.0.0" + stringify-entities "^4.0.0" + zwitch "^2.0.4" + +hast-util-to-jsx-runtime@^2.0.0: + version "2.3.0" + resolved "https://registry.yarnpkg.com/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.0.tgz#3ed27caf8dc175080117706bf7269404a0aa4f7c" + integrity sha512-H/y0+IWPdsLLS738P8tDnrQ8Z+dj12zQQ6WC11TIM21C8WFVoIxcqWXf2H3hiTVZjF1AWqoimGwrTWecWrnmRQ== + dependencies: + "@types/estree" "^1.0.0" + "@types/hast" "^3.0.0" + "@types/unist" "^3.0.0" + comma-separated-tokens "^2.0.0" + devlop "^1.0.0" + estree-util-is-identifier-name "^3.0.0" + hast-util-whitespace "^3.0.0" + mdast-util-mdx-expression "^2.0.0" + mdast-util-mdx-jsx "^3.0.0" + mdast-util-mdxjs-esm "^2.0.0" + property-information "^6.0.0" + space-separated-tokens "^2.0.0" + style-to-object "^1.0.0" + unist-util-position "^5.0.0" + vfile-message "^4.0.0" + +hast-util-to-parse5@^8.0.0: + version "8.0.0" + resolved "https://registry.yarnpkg.com/hast-util-to-parse5/-/hast-util-to-parse5-8.0.0.tgz#477cd42d278d4f036bc2ea58586130f6f39ee6ed" + integrity sha512-3KKrV5ZVI8if87DVSi1vDeByYrkGzg4mEfeu4alwgmmIeARiBLKCZS2uw5Gb6nU9x9Yufyj3iudm6i7nl52PFw== + dependencies: + "@types/hast" "^3.0.0" + comma-separated-tokens "^2.0.0" + devlop "^1.0.0" + property-information "^6.0.0" + space-separated-tokens "^2.0.0" + web-namespaces "^2.0.0" + zwitch "^2.0.0" + +hast-util-to-string@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/hast-util-to-string/-/hast-util-to-string-3.0.0.tgz#2a131948b4b1b26461a2c8ac876e2c88d02946bd" + integrity sha512-OGkAxX1Ua3cbcW6EJ5pT/tslVb90uViVkcJ4ZZIMW/R33DX/AkcJcRrPebPwJkHYwlDHXz4aIwvAAaAdtrACFA== + dependencies: + "@types/hast" "^3.0.0" + +hast-util-to-text@^4.0.0, hast-util-to-text@^4.0.1, hast-util-to-text@^4.0.2: + version "4.0.2" + resolved "https://registry.yarnpkg.com/hast-util-to-text/-/hast-util-to-text-4.0.2.tgz#57b676931e71bf9cb852453678495b3080bfae3e" + integrity sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A== + dependencies: + "@types/hast" "^3.0.0" + "@types/unist" "^3.0.0" + hast-util-is-element "^3.0.0" + unist-util-find-after "^5.0.0" + +hast-util-whitespace@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz#7778ed9d3c92dd9e8c5c8f648a49c21fc51cb621" + integrity sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw== + dependencies: + "@types/hast" "^3.0.0" + +hastscript@^8.0.0: + version "8.0.0" + resolved "https://registry.yarnpkg.com/hastscript/-/hastscript-8.0.0.tgz#4ef795ec8dee867101b9f23cc830d4baf4fd781a" + integrity sha512-dMOtzCEd3ABUeSIISmrETiKuyydk1w0pa+gE/uormcTpSYuaNJPbX1NU3JLyscSLjwAQM8bWMhhIlnCqnRvDTw== + dependencies: + "@types/hast" "^3.0.0" + comma-separated-tokens "^2.0.0" + hast-util-parse-selector "^4.0.0" + property-information "^6.0.0" + space-separated-tokens "^2.0.0" + +hastscript@^9.0.0: + version "9.0.0" + resolved "https://registry.yarnpkg.com/hastscript/-/hastscript-9.0.0.tgz#2b76b9aa3cba8bf6d5280869f6f6f7165c230763" + integrity sha512-jzaLBGavEDKHrc5EfFImKN7nZKKBdSLIdGvCwDZ9TfzbF2ffXiov8CKE445L2Z1Ek2t/m4SKQ2j6Ipv7NyUolw== + dependencies: + "@types/hast" "^3.0.0" + comma-separated-tokens "^2.0.0" + hast-util-parse-selector "^4.0.0" + property-information "^6.0.0" + space-separated-tokens "^2.0.0" + +html-escaper@^3.0.3: + version "3.0.3" + resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-3.0.3.tgz#4d336674652beb1dcbc29ef6b6ba7f6be6fdfed6" + integrity sha512-RuMffC89BOWQoY0WKGpIhn5gX3iI54O6nRA0yC124NYVtzjmFWBIiFd8M0x+ZdX0P9R4lADg1mgP8C7PxGOWuQ== + +html-void-elements@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/html-void-elements/-/html-void-elements-3.0.0.tgz#fc9dbd84af9e747249034d4d62602def6517f1d7" + integrity sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg== + +html-whitespace-sensitive-tag-names@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/html-whitespace-sensitive-tag-names/-/html-whitespace-sensitive-tag-names-3.0.0.tgz#c7c8c11d93c014fba642e240d7f3da39656ab301" + integrity sha512-KlClZ3/Qy5UgvpvVvDomGhnQhNWH5INE8GwvSIQ9CWt1K0zbbXrl7eN5bWaafOZgtmO3jMPwUqmrmEwinhPq1w== + +http-cache-semantics@^4.1.1: + version "4.1.1" + resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz#abe02fcb2985460bf0323be664436ec3476a6d5a" + integrity sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ== + +i18next@^23.11.5: + version "23.15.1" + resolved "https://registry.yarnpkg.com/i18next/-/i18next-23.15.1.tgz#c50de337bf12ca5195e697cc0fbe5f32304871d9" + integrity sha512-wB4abZ3uK7EWodYisHl/asf8UYEhrI/vj/8aoSsrj/ZDxj4/UXPOa1KvFt1Fq5hkUHquNqwFlDprmjZ8iySgYA== + dependencies: + "@babel/runtime" "^7.23.2" + +ieee754@^1.1.13: + version "1.2.1" + resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352" + integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA== + +import-fresh@^3.3.0: + version "3.3.0" + resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b" + integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw== + dependencies: + parent-module "^1.0.0" + resolve-from "^4.0.0" + +import-meta-resolve@^4.1.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/import-meta-resolve/-/import-meta-resolve-4.1.0.tgz#f9db8bead9fafa61adb811db77a2bf22c5399706" + integrity sha512-I6fiaX09Xivtk+THaMfAwnA3MVA5Big1WHF1Dfx9hFuvNIWpXnorlkzhcQf6ehrqQiiZECRt1poOAkPmer3ruw== + +inherits@^2.0.3, inherits@^2.0.4: + version "2.0.4" + resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" + integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== + +ini@4.1.1: + version "4.1.1" + resolved "https://registry.yarnpkg.com/ini/-/ini-4.1.1.tgz#d95b3d843b1e906e56d6747d5447904ff50ce7a1" + integrity sha512-QQnnxNyfvmHFIsj7gkPcYymR8Jdw/o7mp5ZFihxn6h8Ci6fh3Dx4E1gPjpQEpIuPo9XVNY/ZUwh4BPMjGyL01g== + +ini@~1.3.0: + version "1.3.8" + resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c" + integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew== + +inline-style-parser@0.1.1: + version "0.1.1" + resolved "https://registry.yarnpkg.com/inline-style-parser/-/inline-style-parser-0.1.1.tgz#ec8a3b429274e9c0a1f1c4ffa9453a7fef72cea1" + integrity sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q== + +inline-style-parser@0.2.4: + version "0.2.4" + resolved "https://registry.yarnpkg.com/inline-style-parser/-/inline-style-parser-0.2.4.tgz#f4af5fe72e612839fcd453d989a586566d695f22" + integrity sha512-0aO8FkhNZlj/ZIbNi7Lxxr12obT7cL1moPfE4tg1LkX7LlLfC6DeX4l2ZEud1ukP9jNQyNnfzQVqwbwmAATY4Q== + +is-absolute-url@4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/is-absolute-url/-/is-absolute-url-4.0.1.tgz#16e4d487d4fded05cfe0685e53ec86804a5e94dc" + integrity sha512-/51/TKE88Lmm7Gc4/8btclNXWS+g50wXhYJq8HWIBAGUBnoAdRu1aXeh364t/O7wXDAcTJDP8PNuNKWUDWie+A== + +is-alphabetical@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/is-alphabetical/-/is-alphabetical-2.0.1.tgz#01072053ea7c1036df3c7d19a6daaec7f19e789b" + integrity sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ== + +is-alphanumerical@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz#7c03fbe96e3e931113e57f964b0a368cc2dfd875" + integrity sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw== + dependencies: + is-alphabetical "^2.0.0" + is-decimal "^2.0.0" + +is-arrayish@^0.3.1: + version "0.3.2" + resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.3.2.tgz#4574a2ae56f7ab206896fb431eaeed066fdf8f03" + integrity sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ== + +is-binary-path@~2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09" + integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw== + dependencies: + binary-extensions "^2.0.0" + +is-decimal@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/is-decimal/-/is-decimal-2.0.1.tgz#9469d2dc190d0214fd87d78b78caecc0cc14eef7" + integrity sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A== + +is-docker@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-3.0.0.tgz#90093aa3106277d8a77a5910dbae71747e15a200" + integrity sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ== + +is-extendable@^0.1.0: + version "0.1.1" + resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89" + integrity sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw== + +is-extglob@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2" + integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== + +is-fullwidth-code-point@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d" + integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== + +is-glob@^4.0.1, is-glob@~4.0.1: + version "4.0.3" + resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084" + integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== + dependencies: + is-extglob "^2.1.1" + +is-hexadecimal@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz#86b5bf668fca307498d319dfc03289d781a90027" + integrity sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg== + +is-inside-container@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/is-inside-container/-/is-inside-container-1.0.0.tgz#e81fba699662eb31dbdaf26766a61d4814717ea4" + integrity sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA== + dependencies: + is-docker "^3.0.0" + +is-interactive@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/is-interactive/-/is-interactive-2.0.0.tgz#40c57614593826da1100ade6059778d597f16e90" + integrity sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ== + +is-number@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b" + integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== + +is-plain-obj@^4.0.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-4.1.0.tgz#d65025edec3657ce032fd7db63c97883eaed71f0" + integrity sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg== + +is-reference@^3.0.0: + version "3.0.2" + resolved "https://registry.yarnpkg.com/is-reference/-/is-reference-3.0.2.tgz#154747a01f45cd962404ee89d43837af2cba247c" + integrity sha512-v3rht/LgVcsdZa3O2Nqs+NMowLOxeOm7Ay9+/ARQ2F+qEoANRcqrjAZKGN0v8ymUetZGgkp26LTnGT7H0Qo9Pg== + dependencies: + "@types/estree" "*" + +is-unicode-supported@^1.3.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/is-unicode-supported/-/is-unicode-supported-1.3.0.tgz#d824984b616c292a2e198207d4a609983842f714" + integrity sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ== + +is-unicode-supported@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz#09f0ab0de6d3744d48d265ebb98f65d11f2a9b3a" + integrity sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ== + +is-wsl@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-3.1.0.tgz#e1c657e39c10090afcbedec61720f6b924c3cbd2" + integrity sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw== + dependencies: + is-inside-container "^1.0.0" + +js-tokens@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499" + integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== + +js-yaml@^3.13.0, js-yaml@^3.13.1: + version "3.14.1" + resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537" + integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g== + dependencies: + argparse "^1.0.7" + esprima "^4.0.0" + +js-yaml@^4.1.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602" + integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA== + dependencies: + argparse "^2.0.1" + +jsesc@^2.5.1: + version "2.5.2" + resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4" + integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA== + +json-buffer@3.0.1: + version "3.0.1" + resolved "https://registry.yarnpkg.com/json-buffer/-/json-buffer-3.0.1.tgz#9338802a30d3b6605fbe0613e094008ca8c05a13" + integrity sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ== + +json-schema-traverse@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2" + integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug== + +json5@^2.2.3: + version "2.2.3" + resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283" + integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg== + +jsonc-parser@^2.3.0: + version "2.3.1" + resolved "https://registry.yarnpkg.com/jsonc-parser/-/jsonc-parser-2.3.1.tgz#59549150b133f2efacca48fe9ce1ec0659af2342" + integrity sha512-H8jvkz1O50L3dMZCsLqiuB2tA7muqbSg1AtGEkN0leAqGjsUzDJir3Zwr02BhqdcITPg3ei3mZ+HjMocAknhhg== + +jsonc-parser@^3.0.0: + version "3.3.1" + resolved "https://registry.yarnpkg.com/jsonc-parser/-/jsonc-parser-3.3.1.tgz#f2a524b4f7fd11e3d791e559977ad60b98b798b4" + integrity sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ== + +katex@^0.16.0: + version "0.16.11" + resolved "https://registry.yarnpkg.com/katex/-/katex-0.16.11.tgz#4bc84d5584f996abece5f01c6ad11304276a33f5" + integrity sha512-RQrI8rlHY92OLf3rho/Ts8i/XvjgguEjOkO1BEXcU3N8BqPpSzBNwV/G0Ukr+P/l3ivvJUE/Fa/CwbS6HesGNQ== + dependencies: + commander "^8.3.0" + +keyv@^4.5.4: + version "4.5.4" + resolved "https://registry.yarnpkg.com/keyv/-/keyv-4.5.4.tgz#a879a99e29452f942439f2a405e3af8b31d4de93" + integrity sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw== + dependencies: + json-buffer "3.0.1" + +kind-of@^6.0.0, kind-of@^6.0.2: + version "6.0.3" + resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd" + integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw== + +kleur@4.1.5, kleur@^4.1.5: + version "4.1.5" + resolved "https://registry.yarnpkg.com/kleur/-/kleur-4.1.5.tgz#95106101795f7050c6c650f350c683febddb1780" + integrity sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ== + +kleur@^3.0.3: + version "3.0.3" + resolved "https://registry.yarnpkg.com/kleur/-/kleur-3.0.3.tgz#a79c9ecc86ee1ce3fa6206d1216c501f147fc07e" + integrity sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w== + +load-yaml-file@^0.2.0: + version "0.2.0" + resolved "https://registry.yarnpkg.com/load-yaml-file/-/load-yaml-file-0.2.0.tgz#af854edaf2bea89346c07549122753c07372f64d" + integrity sha512-OfCBkGEw4nN6JLtgRidPX6QxjBQGQf72q3si2uvqyFEMbycSFFHwAZeXx6cJgFM9wmLrf9zBwCP3Ivqa+LLZPw== + dependencies: + graceful-fs "^4.1.5" + js-yaml "^3.13.0" + pify "^4.0.1" + strip-bom "^3.0.0" + +locate-path@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0" + integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g== + dependencies: + p-locate "^4.1.0" + +lodash@4.17.21: + version "4.17.21" + resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" + integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== + +log-symbols@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-6.0.0.tgz#bb95e5f05322651cac30c0feb6404f9f2a8a9439" + integrity sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw== + dependencies: + chalk "^5.3.0" + is-unicode-supported "^1.3.0" + +longest-streak@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/longest-streak/-/longest-streak-3.1.0.tgz#62fa67cd958742a1574af9f39866364102d90cd4" + integrity sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g== + +lru-cache@^5.1.1: + version "5.1.1" + resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920" + integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w== + dependencies: + yallist "^3.0.2" + +magic-string@^0.30.11: + version "0.30.11" + resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.30.11.tgz#301a6f93b3e8c2cb13ac1a7a673492c0dfd12954" + integrity sha512-+Wri9p0QHMy+545hKww7YAu5NyzF8iomPL/RQazugQ9+Ez4Ic3mERMd8ZTX5rfK944j+560ZJi8iAwgak1Ac7A== + dependencies: + "@jridgewell/sourcemap-codec" "^1.5.0" + +magicast@^0.3.5: + version "0.3.5" + resolved "https://registry.yarnpkg.com/magicast/-/magicast-0.3.5.tgz#8301c3c7d66704a0771eb1bad74274f0ec036739" + integrity sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ== + dependencies: + "@babel/parser" "^7.25.4" + "@babel/types" "^7.25.4" + source-map-js "^1.2.0" + +markdown-extensions@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/markdown-extensions/-/markdown-extensions-2.0.0.tgz#34bebc83e9938cae16e0e017e4a9814a8330d3c4" + integrity sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q== + +markdown-table@^3.0.0: + version "3.0.3" + resolved "https://registry.yarnpkg.com/markdown-table/-/markdown-table-3.0.3.tgz#e6331d30e493127e031dd385488b5bd326e4a6bd" + integrity sha512-Z1NL3Tb1M9wH4XESsCDEksWoKTdlUafKc4pt0GRwjUyXaCFZ+dc3g2erqB6zm3szA2IUSi7VnPI+o/9jnxh9hw== + +mdast-heading-id@*: + version "2.0.0" + resolved "https://registry.yarnpkg.com/mdast-heading-id/-/mdast-heading-id-2.0.0.tgz#07a55246f2190654392be0c51042548515dd6938" + integrity sha512-JVh0xKqsI3INPzJEqqCiuq3BGde5x6AlBTQAetLQQr9qTiDjX4dCvFhIiGmyPt1rftiHELQPI5obGphIOTXeWQ== + +mdast-util-definitions@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/mdast-util-definitions/-/mdast-util-definitions-6.0.0.tgz#c1bb706e5e76bb93f9a09dd7af174002ae69ac24" + integrity sha512-scTllyX6pnYNZH/AIp/0ePz6s4cZtARxImwoPJ7kS42n+MnVsI4XbnG6d4ibehRIldYMWM2LD7ImQblVhUejVQ== + dependencies: + "@types/mdast" "^4.0.0" + "@types/unist" "^3.0.0" + unist-util-visit "^5.0.0" + +mdast-util-directive@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/mdast-util-directive/-/mdast-util-directive-3.0.0.tgz#3fb1764e705bbdf0afb0d3f889e4404c3e82561f" + integrity sha512-JUpYOqKI4mM3sZcNxmF/ox04XYFFkNwr0CFlrQIkCwbvH0xzMCqkMqAde9wRd80VAhaUrwFwKm2nxretdT1h7Q== + dependencies: + "@types/mdast" "^4.0.0" + "@types/unist" "^3.0.0" + devlop "^1.0.0" + mdast-util-from-markdown "^2.0.0" + mdast-util-to-markdown "^2.0.0" + parse-entities "^4.0.0" + stringify-entities "^4.0.0" + unist-util-visit-parents "^6.0.0" + +mdast-util-find-and-replace@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.1.tgz#a6fc7b62f0994e973490e45262e4bc07607b04e0" + integrity sha512-SG21kZHGC3XRTSUhtofZkBzZTJNM5ecCi0SK2IMKmSXR8vO3peL+kb1O0z7Zl83jKtutG4k5Wv/W7V3/YHvzPA== + dependencies: + "@types/mdast" "^4.0.0" + escape-string-regexp "^5.0.0" + unist-util-is "^6.0.0" + unist-util-visit-parents "^6.0.0" + +mdast-util-from-markdown@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.1.tgz#32a6e8f512b416e1f51eb817fc64bd867ebcd9cc" + integrity sha512-aJEUyzZ6TzlsX2s5B4Of7lN7EQtAxvtradMMglCQDyaTFgse6CmtmdJ15ElnVRlCg1vpNyVtbem0PWzlNieZsA== + dependencies: + "@types/mdast" "^4.0.0" + "@types/unist" "^3.0.0" + decode-named-character-reference "^1.0.0" + devlop "^1.0.0" + mdast-util-to-string "^4.0.0" + micromark "^4.0.0" + micromark-util-decode-numeric-character-reference "^2.0.0" + micromark-util-decode-string "^2.0.0" + micromark-util-normalize-identifier "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + unist-util-stringify-position "^4.0.0" + +mdast-util-gfm-autolink-literal@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz#abd557630337bd30a6d5a4bd8252e1c2dc0875d5" + integrity sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ== + dependencies: + "@types/mdast" "^4.0.0" + ccount "^2.0.0" + devlop "^1.0.0" + mdast-util-find-and-replace "^3.0.0" + micromark-util-character "^2.0.0" + +mdast-util-gfm-footnote@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.0.0.tgz#25a1753c7d16db8bfd53cd84fe50562bd1e6d6a9" + integrity sha512-5jOT2boTSVkMnQ7LTrd6n/18kqwjmuYqo7JUPe+tRCY6O7dAuTFMtTPauYYrMPpox9hlN0uOx/FL8XvEfG9/mQ== + dependencies: + "@types/mdast" "^4.0.0" + devlop "^1.1.0" + mdast-util-from-markdown "^2.0.0" + mdast-util-to-markdown "^2.0.0" + micromark-util-normalize-identifier "^2.0.0" + +mdast-util-gfm-strikethrough@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz#d44ef9e8ed283ac8c1165ab0d0dfd058c2764c16" + integrity sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg== + dependencies: + "@types/mdast" "^4.0.0" + mdast-util-from-markdown "^2.0.0" + mdast-util-to-markdown "^2.0.0" + +mdast-util-gfm-table@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz#7a435fb6223a72b0862b33afbd712b6dae878d38" + integrity sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg== + dependencies: + "@types/mdast" "^4.0.0" + devlop "^1.0.0" + markdown-table "^3.0.0" + mdast-util-from-markdown "^2.0.0" + mdast-util-to-markdown "^2.0.0" + +mdast-util-gfm-task-list-item@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz#e68095d2f8a4303ef24094ab642e1047b991a936" + integrity sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ== + dependencies: + "@types/mdast" "^4.0.0" + devlop "^1.0.0" + mdast-util-from-markdown "^2.0.0" + mdast-util-to-markdown "^2.0.0" + +mdast-util-gfm@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/mdast-util-gfm/-/mdast-util-gfm-3.0.0.tgz#3f2aecc879785c3cb6a81ff3a243dc11eca61095" + integrity sha512-dgQEX5Amaq+DuUqf26jJqSK9qgixgd6rYDHAv4aTBuA92cTknZlKpPfa86Z/s8Dj8xsAQpFfBmPUHWJBWqS4Bw== + dependencies: + mdast-util-from-markdown "^2.0.0" + mdast-util-gfm-autolink-literal "^2.0.0" + mdast-util-gfm-footnote "^2.0.0" + mdast-util-gfm-strikethrough "^2.0.0" + mdast-util-gfm-table "^2.0.0" + mdast-util-gfm-task-list-item "^2.0.0" + mdast-util-to-markdown "^2.0.0" + +mdast-util-math@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/mdast-util-math/-/mdast-util-math-3.0.0.tgz#8d79dd3baf8ab8ac781f62b8853768190b9a00b0" + integrity sha512-Tl9GBNeG/AhJnQM221bJR2HPvLOSnLE/T9cJI9tlc6zwQk2nPk/4f0cHkOdEixQPC/j8UtKDdITswvLAy1OZ1w== + dependencies: + "@types/hast" "^3.0.0" + "@types/mdast" "^4.0.0" + devlop "^1.0.0" + longest-streak "^3.0.0" + mdast-util-from-markdown "^2.0.0" + mdast-util-to-markdown "^2.1.0" + unist-util-remove-position "^5.0.0" + +mdast-util-mdx-expression@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz#43f0abac9adc756e2086f63822a38c8d3c3a5096" + integrity sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ== + dependencies: + "@types/estree-jsx" "^1.0.0" + "@types/hast" "^3.0.0" + "@types/mdast" "^4.0.0" + devlop "^1.0.0" + mdast-util-from-markdown "^2.0.0" + mdast-util-to-markdown "^2.0.0" + +mdast-util-mdx-jsx@^3.0.0: + version "3.1.3" + resolved "https://registry.yarnpkg.com/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.3.tgz#76b957b3da18ebcfd0de3a9b4451dcd6fdec2320" + integrity sha512-bfOjvNt+1AcbPLTFMFWY149nJz0OjmewJs3LQQ5pIyVGxP4CdOqNVJL6kTaM5c68p8q82Xv3nCyFfUnuEcH3UQ== + dependencies: + "@types/estree-jsx" "^1.0.0" + "@types/hast" "^3.0.0" + "@types/mdast" "^4.0.0" + "@types/unist" "^3.0.0" + ccount "^2.0.0" + devlop "^1.1.0" + mdast-util-from-markdown "^2.0.0" + mdast-util-to-markdown "^2.0.0" + parse-entities "^4.0.0" + stringify-entities "^4.0.0" + unist-util-stringify-position "^4.0.0" + vfile-message "^4.0.0" + +mdast-util-mdx@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/mdast-util-mdx/-/mdast-util-mdx-3.0.0.tgz#792f9cf0361b46bee1fdf1ef36beac424a099c41" + integrity sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w== + dependencies: + mdast-util-from-markdown "^2.0.0" + mdast-util-mdx-expression "^2.0.0" + mdast-util-mdx-jsx "^3.0.0" + mdast-util-mdxjs-esm "^2.0.0" + mdast-util-to-markdown "^2.0.0" + +mdast-util-mdxjs-esm@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz#019cfbe757ad62dd557db35a695e7314bcc9fa97" + integrity sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg== + dependencies: + "@types/estree-jsx" "^1.0.0" + "@types/hast" "^3.0.0" + "@types/mdast" "^4.0.0" + devlop "^1.0.0" + mdast-util-from-markdown "^2.0.0" + mdast-util-to-markdown "^2.0.0" + +mdast-util-phrasing@^4.0.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz#7cc0a8dec30eaf04b7b1a9661a92adb3382aa6e3" + integrity sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w== + dependencies: + "@types/mdast" "^4.0.0" + unist-util-is "^6.0.0" + +mdast-util-to-hast@^13.0.0: + version "13.2.0" + resolved "https://registry.yarnpkg.com/mdast-util-to-hast/-/mdast-util-to-hast-13.2.0.tgz#5ca58e5b921cc0a3ded1bc02eed79a4fe4fe41f4" + integrity sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA== + dependencies: + "@types/hast" "^3.0.0" + "@types/mdast" "^4.0.0" + "@ungap/structured-clone" "^1.0.0" + devlop "^1.0.0" + micromark-util-sanitize-uri "^2.0.0" + trim-lines "^3.0.0" + unist-util-position "^5.0.0" + unist-util-visit "^5.0.0" + vfile "^6.0.0" + +mdast-util-to-markdown@^2.0.0, mdast-util-to-markdown@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.0.tgz#9813f1d6e0cdaac7c244ec8c6dabfdb2102ea2b4" + integrity sha512-SR2VnIEdVNCJbP6y7kVTJgPLifdr8WEU440fQec7qHoHOUz/oJ2jmNRqdDQ3rbiStOXb2mCDGTuwsK5OPUgYlQ== + dependencies: + "@types/mdast" "^4.0.0" + "@types/unist" "^3.0.0" + longest-streak "^3.0.0" + mdast-util-phrasing "^4.0.0" + mdast-util-to-string "^4.0.0" + micromark-util-decode-string "^2.0.0" + unist-util-visit "^5.0.0" + zwitch "^2.0.0" + +mdast-util-to-string@4.0.0, mdast-util-to-string@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz#7a5121475556a04e7eddeb67b264aae79d312814" + integrity sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg== + dependencies: + "@types/mdast" "^4.0.0" + +merge2@^1.3.0: + version "1.4.1" + resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae" + integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg== + +micromark-core-commonmark@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/micromark-core-commonmark/-/micromark-core-commonmark-2.0.1.tgz#9a45510557d068605c6e9a80f282b2bb8581e43d" + integrity sha512-CUQyKr1e///ZODyD1U3xit6zXwy1a8q2a1S1HKtIlmgvurrEpaw/Y9y6KSIbF8P59cn/NjzHyO+Q2fAyYLQrAA== + dependencies: + decode-named-character-reference "^1.0.0" + devlop "^1.0.0" + micromark-factory-destination "^2.0.0" + micromark-factory-label "^2.0.0" + micromark-factory-space "^2.0.0" + micromark-factory-title "^2.0.0" + micromark-factory-whitespace "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-chunked "^2.0.0" + micromark-util-classify-character "^2.0.0" + micromark-util-html-tag-name "^2.0.0" + micromark-util-normalize-identifier "^2.0.0" + micromark-util-resolve-all "^2.0.0" + micromark-util-subtokenize "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-extension-directive@^3.0.0: + version "3.0.2" + resolved "https://registry.yarnpkg.com/micromark-extension-directive/-/micromark-extension-directive-3.0.2.tgz#2eb61985d1995a7c1ff7621676a4f32af29409e8" + integrity sha512-wjcXHgk+PPdmvR58Le9d7zQYWy+vKEU9Se44p2CrCDPiLr2FMyiT4Fyb5UFKFC66wGB3kPlgD7q3TnoqPS7SZA== + dependencies: + devlop "^1.0.0" + micromark-factory-space "^2.0.0" + micromark-factory-whitespace "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + parse-entities "^4.0.0" + +micromark-extension-gfm-autolink-literal@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz#6286aee9686c4462c1e3552a9d505feddceeb935" + integrity sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw== + dependencies: + micromark-util-character "^2.0.0" + micromark-util-sanitize-uri "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-extension-gfm-footnote@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz#4dab56d4e398b9853f6fe4efac4fc9361f3e0750" + integrity sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw== + dependencies: + devlop "^1.0.0" + micromark-core-commonmark "^2.0.0" + micromark-factory-space "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-normalize-identifier "^2.0.0" + micromark-util-sanitize-uri "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-extension-gfm-strikethrough@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz#86106df8b3a692b5f6a92280d3879be6be46d923" + integrity sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw== + dependencies: + devlop "^1.0.0" + micromark-util-chunked "^2.0.0" + micromark-util-classify-character "^2.0.0" + micromark-util-resolve-all "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-extension-gfm-table@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.0.tgz#5cadedfbb29fca7abf752447967003dc3b6583c9" + integrity sha512-Ub2ncQv+fwD70/l4ou27b4YzfNaCJOvyX4HxXU15m7mpYY+rjuWzsLIPZHJL253Z643RpbcP1oeIJlQ/SKW67g== + dependencies: + devlop "^1.0.0" + micromark-factory-space "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-extension-gfm-tagfilter@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz#f26d8a7807b5985fba13cf61465b58ca5ff7dc57" + integrity sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg== + dependencies: + micromark-util-types "^2.0.0" + +micromark-extension-gfm-task-list-item@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz#bcc34d805639829990ec175c3eea12bb5b781f2c" + integrity sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw== + dependencies: + devlop "^1.0.0" + micromark-factory-space "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-extension-gfm@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz#3e13376ab95dd7a5cfd0e29560dfe999657b3c5b" + integrity sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w== + dependencies: + micromark-extension-gfm-autolink-literal "^2.0.0" + micromark-extension-gfm-footnote "^2.0.0" + micromark-extension-gfm-strikethrough "^2.0.0" + micromark-extension-gfm-table "^2.0.0" + micromark-extension-gfm-tagfilter "^2.0.0" + micromark-extension-gfm-task-list-item "^2.0.0" + micromark-util-combine-extensions "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-extension-math@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/micromark-extension-math/-/micromark-extension-math-3.1.0.tgz#c42ee3b1dd5a9a03584e83dd8f08e3de510212c1" + integrity sha512-lvEqd+fHjATVs+2v/8kg9i5Q0AP2k85H0WUOwpIVvUML8BapsMvh1XAogmQjOCsLpoKRCVQqEkQBB3NhVBcsOg== + dependencies: + "@types/katex" "^0.16.0" + devlop "^1.0.0" + katex "^0.16.0" + micromark-factory-space "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-extension-mdx-expression@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.0.tgz#1407b9ce69916cf5e03a196ad9586889df25302a" + integrity sha512-sI0nwhUDz97xyzqJAbHQhp5TfaxEvZZZ2JDqUo+7NvyIYG6BZ5CPPqj2ogUoPJlmXHBnyZUzISg9+oUmU6tUjQ== + dependencies: + "@types/estree" "^1.0.0" + devlop "^1.0.0" + micromark-factory-mdx-expression "^2.0.0" + micromark-factory-space "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-events-to-acorn "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-extension-mdx-jsx@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.1.tgz#5abb83da5ddc8e473a374453e6ea56fbd66b59ad" + integrity sha512-vNuFb9czP8QCtAQcEJn0UJQJZA8Dk6DXKBqx+bg/w0WGuSxDxNr7hErW89tHUY31dUW4NqEOWwmEUNhjTFmHkg== + dependencies: + "@types/acorn" "^4.0.0" + "@types/estree" "^1.0.0" + devlop "^1.0.0" + estree-util-is-identifier-name "^3.0.0" + micromark-factory-mdx-expression "^2.0.0" + micromark-factory-space "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-events-to-acorn "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + vfile-message "^4.0.0" + +micromark-extension-mdx-md@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-extension-mdx-md/-/micromark-extension-mdx-md-2.0.0.tgz#1d252881ea35d74698423ab44917e1f5b197b92d" + integrity sha512-EpAiszsB3blw4Rpba7xTOUptcFeBFi+6PY8VnJ2hhimH+vCQDirWgsMpz7w1XcZE7LVrSAUGb9VJpG9ghlYvYQ== + dependencies: + micromark-util-types "^2.0.0" + +micromark-extension-mdxjs-esm@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/micromark-extension-mdxjs-esm/-/micromark-extension-mdxjs-esm-3.0.0.tgz#de21b2b045fd2059bd00d36746081de38390d54a" + integrity sha512-DJFl4ZqkErRpq/dAPyeWp15tGrcrrJho1hKK5uBS70BCtfrIFg81sqcTVu3Ta+KD1Tk5vAtBNElWxtAa+m8K9A== + dependencies: + "@types/estree" "^1.0.0" + devlop "^1.0.0" + micromark-core-commonmark "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-events-to-acorn "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + unist-util-position-from-estree "^2.0.0" + vfile-message "^4.0.0" + +micromark-extension-mdxjs@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/micromark-extension-mdxjs/-/micromark-extension-mdxjs-3.0.0.tgz#b5a2e0ed449288f3f6f6c544358159557549de18" + integrity sha512-A873fJfhnJ2siZyUrJ31l34Uqwy4xIFmvPY1oj+Ean5PHcPBYzEsvqvWGaWcfEIr11O5Dlw3p2y0tZWpKHDejQ== + dependencies: + acorn "^8.0.0" + acorn-jsx "^5.0.0" + micromark-extension-mdx-expression "^3.0.0" + micromark-extension-mdx-jsx "^3.0.0" + micromark-extension-mdx-md "^2.0.0" + micromark-extension-mdxjs-esm "^3.0.0" + micromark-util-combine-extensions "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-factory-destination@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-factory-destination/-/micromark-factory-destination-2.0.0.tgz#857c94debd2c873cba34e0445ab26b74f6a6ec07" + integrity sha512-j9DGrQLm/Uhl2tCzcbLhy5kXsgkHUrjJHg4fFAeoMRwJmJerT9aw4FEhIbZStWN8A3qMwOp1uzHr4UL8AInxtA== + dependencies: + micromark-util-character "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-factory-label@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-factory-label/-/micromark-factory-label-2.0.0.tgz#17c5c2e66ce39ad6f4fc4cbf40d972f9096f726a" + integrity sha512-RR3i96ohZGde//4WSe/dJsxOX6vxIg9TimLAS3i4EhBAFx8Sm5SmqVfR8E87DPSR31nEAjZfbt91OMZWcNgdZw== + dependencies: + devlop "^1.0.0" + micromark-util-character "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-factory-mdx-expression@^2.0.0: + version "2.0.2" + resolved "https://registry.yarnpkg.com/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.2.tgz#2afaa8ba6d5f63e0cead3e4dee643cad184ca260" + integrity sha512-5E5I2pFzJyg2CtemqAbcyCktpHXuJbABnsb32wX2U8IQKhhVFBqkcZR5LRm1WVoFqa4kTueZK4abep7wdo9nrw== + dependencies: + "@types/estree" "^1.0.0" + devlop "^1.0.0" + micromark-factory-space "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-events-to-acorn "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + unist-util-position-from-estree "^2.0.0" + vfile-message "^4.0.0" + +micromark-factory-space@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-factory-space/-/micromark-factory-space-2.0.0.tgz#5e7afd5929c23b96566d0e1ae018ae4fcf81d030" + integrity sha512-TKr+LIDX2pkBJXFLzpyPyljzYK3MtmllMUMODTQJIUfDGncESaqB90db9IAUcz4AZAJFdd8U9zOp9ty1458rxg== + dependencies: + micromark-util-character "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-factory-title@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-factory-title/-/micromark-factory-title-2.0.0.tgz#726140fc77892af524705d689e1cf06c8a83ea95" + integrity sha512-jY8CSxmpWLOxS+t8W+FG3Xigc0RDQA9bKMY/EwILvsesiRniiVMejYTE4wumNc2f4UbAa4WsHqe3J1QS1sli+A== + dependencies: + micromark-factory-space "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-factory-whitespace@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.0.tgz#9e92eb0f5468083381f923d9653632b3cfb5f763" + integrity sha512-28kbwaBjc5yAI1XadbdPYHX/eDnqaUFVikLwrO7FDnKG7lpgxnvk/XGRhX/PN0mOZ+dBSZ+LgunHS+6tYQAzhA== + dependencies: + micromark-factory-space "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-heading-id@*: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-heading-id/-/micromark-heading-id-2.0.0.tgz#242ab53877a8b82e6e448910bc09a8f2677a6ad2" + integrity sha512-TdR5WCmwuCroK8QrfX0/4w9bjj3ayN0GzatxGV/lWQKmM75kNKVZEmdvKZS4MOskARxWXu1WHdIJjMSVMBegow== + dependencies: + micromark-util-symbol "^2.0.0" + +micromark-util-character@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/micromark-util-character/-/micromark-util-character-2.1.0.tgz#31320ace16b4644316f6bf057531689c71e2aee1" + integrity sha512-KvOVV+X1yLBfs9dCBSopq/+G1PcgT3lAK07mC4BzXi5E7ahzMAF8oIupDDJ6mievI6F+lAATkbQQlQixJfT3aQ== + dependencies: + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-util-chunked@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-chunked/-/micromark-util-chunked-2.0.0.tgz#e51f4db85fb203a79dbfef23fd41b2f03dc2ef89" + integrity sha512-anK8SWmNphkXdaKgz5hJvGa7l00qmcaUQoMYsBwDlSKFKjc6gjGXPDw3FNL3Nbwq5L8gE+RCbGqTw49FK5Qyvg== + dependencies: + micromark-util-symbol "^2.0.0" + +micromark-util-classify-character@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-classify-character/-/micromark-util-classify-character-2.0.0.tgz#8c7537c20d0750b12df31f86e976d1d951165f34" + integrity sha512-S0ze2R9GH+fu41FA7pbSqNWObo/kzwf8rN/+IGlW/4tC6oACOs8B++bh+i9bVyNnwCcuksbFwsBme5OCKXCwIw== + dependencies: + micromark-util-character "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-util-combine-extensions@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.0.tgz#75d6ab65c58b7403616db8d6b31315013bfb7ee5" + integrity sha512-vZZio48k7ON0fVS3CUgFatWHoKbbLTK/rT7pzpJ4Bjp5JjkZeasRfrS9wsBdDJK2cJLHMckXZdzPSSr1B8a4oQ== + dependencies: + micromark-util-chunked "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-util-decode-numeric-character-reference@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.1.tgz#2698bbb38f2a9ba6310e359f99fcb2b35a0d2bd5" + integrity sha512-bmkNc7z8Wn6kgjZmVHOX3SowGmVdhYS7yBpMnuMnPzDq/6xwVA604DuOXMZTO1lvq01g+Adfa0pE2UKGlxL1XQ== + dependencies: + micromark-util-symbol "^2.0.0" + +micromark-util-decode-string@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-decode-string/-/micromark-util-decode-string-2.0.0.tgz#7dfa3a63c45aecaa17824e656bcdb01f9737154a" + integrity sha512-r4Sc6leeUTn3P6gk20aFMj2ntPwn6qpDZqWvYmAG6NgvFTIlj4WtrAudLi65qYoaGdXYViXYw2pkmn7QnIFasA== + dependencies: + decode-named-character-reference "^1.0.0" + micromark-util-character "^2.0.0" + micromark-util-decode-numeric-character-reference "^2.0.0" + micromark-util-symbol "^2.0.0" + +micromark-util-encode@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-encode/-/micromark-util-encode-2.0.0.tgz#0921ac7953dc3f1fd281e3d1932decfdb9382ab1" + integrity sha512-pS+ROfCXAGLWCOc8egcBvT0kf27GoWMqtdarNfDcjb6YLuV5cM3ioG45Ys2qOVqeqSbjaKg72vU+Wby3eddPsA== + +micromark-util-events-to-acorn@^2.0.0: + version "2.0.2" + resolved "https://registry.yarnpkg.com/micromark-util-events-to-acorn/-/micromark-util-events-to-acorn-2.0.2.tgz#4275834f5453c088bd29cd72dfbf80e3327cec07" + integrity sha512-Fk+xmBrOv9QZnEDguL9OI9/NQQp6Hz4FuQ4YmCb/5V7+9eAh1s6AYSvL20kHkD67YIg7EpE54TiSlcsf3vyZgA== + dependencies: + "@types/acorn" "^4.0.0" + "@types/estree" "^1.0.0" + "@types/unist" "^3.0.0" + devlop "^1.0.0" + estree-util-visit "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + vfile-message "^4.0.0" + +micromark-util-html-tag-name@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.0.tgz#ae34b01cbe063363847670284c6255bb12138ec4" + integrity sha512-xNn4Pqkj2puRhKdKTm8t1YHC/BAjx6CEwRFXntTaRf/x16aqka6ouVoutm+QdkISTlT7e2zU7U4ZdlDLJd2Mcw== + +micromark-util-normalize-identifier@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.0.tgz#91f9a4e65fe66cc80c53b35b0254ad67aa431d8b" + integrity sha512-2xhYT0sfo85FMrUPtHcPo2rrp1lwbDEEzpx7jiH2xXJLqBuy4H0GgXk5ToU8IEwoROtXuL8ND0ttVa4rNqYK3w== + dependencies: + micromark-util-symbol "^2.0.0" + +micromark-util-resolve-all@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.0.tgz#189656e7e1a53d0c86a38a652b284a252389f364" + integrity sha512-6KU6qO7DZ7GJkaCgwBNtplXCvGkJToU86ybBAUdavvgsCiG8lSSvYxr9MhwmQ+udpzywHsl4RpGJsYWG1pDOcA== + dependencies: + micromark-util-types "^2.0.0" + +micromark-util-sanitize-uri@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.0.tgz#ec8fbf0258e9e6d8f13d9e4770f9be64342673de" + integrity sha512-WhYv5UEcZrbAtlsnPuChHUAsu/iBPOVaEVsntLBIdpibO0ddy8OzavZz3iL2xVvBZOpolujSliP65Kq0/7KIYw== + dependencies: + micromark-util-character "^2.0.0" + micromark-util-encode "^2.0.0" + micromark-util-symbol "^2.0.0" + +micromark-util-subtokenize@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/micromark-util-subtokenize/-/micromark-util-subtokenize-2.0.1.tgz#76129c49ac65da6e479c09d0ec4b5f29ec6eace5" + integrity sha512-jZNtiFl/1aY73yS3UGQkutD0UbhTt68qnRpw2Pifmz5wV9h8gOVsN70v+Lq/f1rKaU/W8pxRe8y8Q9FX1AOe1Q== + dependencies: + devlop "^1.0.0" + micromark-util-chunked "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-util-symbol@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-symbol/-/micromark-util-symbol-2.0.0.tgz#12225c8f95edf8b17254e47080ce0862d5db8044" + integrity sha512-8JZt9ElZ5kyTnO94muPxIGS8oyElRJaiJO8EzV6ZSyGQ1Is8xwl4Q45qU5UOg+bGH4AikWziz0iN4sFLWs8PGw== + +micromark-util-types@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-types/-/micromark-util-types-2.0.0.tgz#63b4b7ffeb35d3ecf50d1ca20e68fc7caa36d95e" + integrity sha512-oNh6S2WMHWRZrmutsRmDDfkzKtxF+bc2VxLC9dvtrDIRFln627VsFP6fLMgTryGDljgLPjkrzQSDcPrjPyDJ5w== + +micromark@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/micromark/-/micromark-4.0.0.tgz#84746a249ebd904d9658cfabc1e8e5f32cbc6249" + integrity sha512-o/sd0nMof8kYff+TqcDx3VSrgBTcZpSvYcAHIfHhv5VAuNmisCxjhx6YmxS8PFEpb9z5WKWKPdzf0jM23ro3RQ== + dependencies: + "@types/debug" "^4.0.0" + debug "^4.0.0" + decode-named-character-reference "^1.0.0" + devlop "^1.0.0" + micromark-core-commonmark "^2.0.0" + micromark-factory-space "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-chunked "^2.0.0" + micromark-util-combine-extensions "^2.0.0" + micromark-util-decode-numeric-character-reference "^2.0.0" + micromark-util-encode "^2.0.0" + micromark-util-normalize-identifier "^2.0.0" + micromark-util-resolve-all "^2.0.0" + micromark-util-sanitize-uri "^2.0.0" + micromark-util-subtokenize "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromatch@^4.0.2, micromatch@^4.0.4, micromatch@^4.0.8: + version "4.0.8" + resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.8.tgz#d66fa18f3a47076789320b9b1af32bd86d9fa202" + integrity sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA== + dependencies: + braces "^3.0.3" + picomatch "^2.3.1" + +mimic-function@^5.0.0: + version "5.0.1" + resolved "https://registry.yarnpkg.com/mimic-function/-/mimic-function-5.0.1.tgz#acbe2b3349f99b9deaca7fb70e48b83e94e67076" + integrity sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA== + +mimic-response@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/mimic-response/-/mimic-response-3.1.0.tgz#2d1d59af9c1b129815accc2c46a022a5ce1fa3c9" + integrity sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ== + +minimist@^1.2.0, minimist@^1.2.3: + version "1.2.8" + resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c" + integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== + +mkdirp-classic@^0.5.2, mkdirp-classic@^0.5.3: + version "0.5.3" + resolved "https://registry.yarnpkg.com/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz#fa10c9115cc6d8865be221ba47ee9bed78601113" + integrity sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A== + +mrmime@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/mrmime/-/mrmime-2.0.0.tgz#151082a6e06e59a9a39b46b3e14d5cfe92b3abb4" + integrity sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw== + +ms@^2.1.3: + version "2.1.3" + resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2" + integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== + +muggle-string@^0.4.1: + version "0.4.1" + resolved "https://registry.yarnpkg.com/muggle-string/-/muggle-string-0.4.1.tgz#3b366bd43b32f809dc20659534dd30e7c8a0d328" + integrity sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ== + +nanoid@^3.3.7: + version "3.3.7" + resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.7.tgz#d0c301a691bc8d54efa0a2226ccf3fe2fd656bd8" + integrity sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g== + +napi-build-utils@^1.0.1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/napi-build-utils/-/napi-build-utils-1.0.2.tgz#b1fddc0b2c46e380a0b7a76f984dd47c41a13806" + integrity sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg== + +neotraverse@^0.6.18: + version "0.6.18" + resolved "https://registry.yarnpkg.com/neotraverse/-/neotraverse-0.6.18.tgz#abcb33dda2e8e713cf6321b29405e822230cdb30" + integrity sha512-Z4SmBUweYa09+o6pG+eASabEpP6QkQ70yHj351pQoEXIs8uHbaU2DWVmzBANKgflPa47A50PtB2+NgRpQvr7vA== + +nlcst-to-string@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/nlcst-to-string/-/nlcst-to-string-4.0.0.tgz#05511e8461ebfb415952eb0b7e9a1a7d40471bd4" + integrity sha512-YKLBCcUYKAg0FNlOBT6aI91qFmSiFKiluk655WzPF+DDMA02qIyy8uiRqI8QXtcFpEvll12LpL5MXqEmAZ+dcA== + dependencies: + "@types/nlcst" "^2.0.0" + +node-abi@^3.3.0: + version "3.68.0" + resolved "https://registry.yarnpkg.com/node-abi/-/node-abi-3.68.0.tgz#8f37fb02ecf4f43ebe694090dcb52e0c4cc4ba25" + integrity sha512-7vbj10trelExNjFSBm5kTvZXXa7pZyKWx9RCKIyqe6I9Ev3IzGpQoqBP3a+cOdxY+pWj6VkP28n/2wWysBHD/A== + dependencies: + semver "^7.3.5" + +node-addon-api@^6.1.0: + version "6.1.0" + resolved "https://registry.yarnpkg.com/node-addon-api/-/node-addon-api-6.1.0.tgz#ac8470034e58e67d0c6f1204a18ae6995d9c0d76" + integrity sha512-+eawOlIgy680F0kBzPUNFhMZGtJ1YmqM6l4+Crf4IkImjYrO/mqPwRMh352g23uIaQKFItcQ64I7KMaJxHgAVA== + +node-releases@^2.0.18: + version "2.0.18" + resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.18.tgz#f010e8d35e2fe8d6b2944f03f70213ecedc4ca3f" + integrity sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g== + +normalize-path@^3.0.0, normalize-path@~3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65" + integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== + +not@^0.1.0: + version "0.1.0" + resolved "https://registry.yarnpkg.com/not/-/not-0.1.0.tgz#c9691c1746c55dcfbe54cbd8bd4ff041bc2b519d" + integrity sha512-5PDmaAsVfnWUgTUbJ3ERwn7u79Z0dYxN9ErxCpVJJqe2RK0PJ3z+iFUxuqjwtlDDegXvtWoxD/3Fzxox7tFGWA== + +nth-check@^2.0.0: + version "2.1.1" + resolved "https://registry.yarnpkg.com/nth-check/-/nth-check-2.1.1.tgz#c9eab428effce36cd6b92c924bdb000ef1f1ed1d" + integrity sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w== + dependencies: + boolbase "^1.0.0" + +once@^1.3.1, once@^1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" + integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== + dependencies: + wrappy "1" + +onetime@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/onetime/-/onetime-7.0.0.tgz#9f16c92d8c9ef5120e3acd9dd9957cceecc1ab60" + integrity sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ== + dependencies: + mimic-function "^5.0.0" + +oniguruma-to-js@0.4.3: + version "0.4.3" + resolved "https://registry.yarnpkg.com/oniguruma-to-js/-/oniguruma-to-js-0.4.3.tgz#8d899714c21f5c7d59a3c0008ca50e848086d740" + integrity sha512-X0jWUcAlxORhOqqBREgPMgnshB7ZGYszBNspP+tS9hPD3l13CdaXcHbgImoHUHlrvGx/7AvFEkTRhAGYh+jzjQ== + dependencies: + regex "^4.3.2" + +ora@^8.1.0: + version "8.1.0" + resolved "https://registry.yarnpkg.com/ora/-/ora-8.1.0.tgz#c3db2f9f83a2bec9e8ab71fe3b9ae234d65ca3a8" + integrity sha512-GQEkNkH/GHOhPFXcqZs3IDahXEQcQxsSjEkK4KvEEST4t7eNzoMjxTzef+EZ+JluDEV+Raoi3WQ2CflnRdSVnQ== + dependencies: + chalk "^5.3.0" + cli-cursor "^5.0.0" + cli-spinners "^2.9.2" + is-interactive "^2.0.0" + is-unicode-supported "^2.0.0" + log-symbols "^6.0.0" + stdin-discarder "^0.2.2" + string-width "^7.2.0" + strip-ansi "^7.1.0" + +p-limit@^2.2.0: + version "2.3.0" + resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1" + integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w== + dependencies: + p-try "^2.0.0" + +p-limit@^6.1.0: + version "6.1.0" + resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-6.1.0.tgz#d91f9364d3fdff89b0a45c70d04ad4e0df30a0e8" + integrity sha512-H0jc0q1vOzlEk0TqAKXKZxdl7kX3OFUzCnNVUnq5Pc3DGo0kpeaMuPqxQn235HibwBEb0/pm9dgKTjXy66fBkg== + dependencies: + yocto-queue "^1.1.1" + +p-locate@^4.1.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07" + integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A== + dependencies: + p-limit "^2.2.0" + +p-queue@^8.0.1: + version "8.0.1" + resolved "https://registry.yarnpkg.com/p-queue/-/p-queue-8.0.1.tgz#718b7f83836922ef213ddec263ff4223ce70bef8" + integrity sha512-NXzu9aQJTAzbBqOt2hwsR63ea7yvxJc0PwN/zobNAudYfb1B7R08SzB4TsLeSbUCuG467NhnoT0oO6w1qRO+BA== + dependencies: + eventemitter3 "^5.0.1" + p-timeout "^6.1.2" + +p-timeout@^6.1.2: + version "6.1.2" + resolved "https://registry.yarnpkg.com/p-timeout/-/p-timeout-6.1.2.tgz#22b8d8a78abf5e103030211c5fc6dee1166a6aa5" + integrity sha512-UbD77BuZ9Bc9aABo74gfXhNvzC9Tx7SxtHSh1fxvx3jTLLYvmVhiQZZrJzqqU0jKbN32kb5VOKiLEQI/3bIjgQ== + +p-try@^2.0.0: + version "2.2.0" + resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6" + integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ== + +pagefind@^1.0.3: + version "1.1.1" + resolved "https://registry.yarnpkg.com/pagefind/-/pagefind-1.1.1.tgz#0fce88df2f2e1ee1c4f92ea024443c78ae271e64" + integrity sha512-U2YR0dQN5B2fbIXrLtt/UXNS0yWSSYfePaad1KcBPTi0p+zRtsVjwmoPaMQgTks5DnHNbmDxyJUL5TGaLljK3A== + optionalDependencies: + "@pagefind/darwin-arm64" "1.1.1" + "@pagefind/darwin-x64" "1.1.1" + "@pagefind/linux-arm64" "1.1.1" + "@pagefind/linux-x64" "1.1.1" + "@pagefind/windows-x64" "1.1.1" + +parent-module@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2" + integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g== + dependencies: + callsites "^3.0.0" + +parent-module@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-2.0.0.tgz#fa71f88ff1a50c27e15d8ff74e0e3a9523bf8708" + integrity sha512-uo0Z9JJeWzv8BG+tRcapBKNJ0dro9cLyczGzulS6EfeyAdeC9sbojtW6XwvYxJkEne9En+J2XEl4zyglVeIwFg== + dependencies: + callsites "^3.1.0" + +parse-entities@^4.0.0: + version "4.0.1" + resolved "https://registry.yarnpkg.com/parse-entities/-/parse-entities-4.0.1.tgz#4e2a01111fb1c986549b944af39eeda258fc9e4e" + integrity sha512-SWzvYcSJh4d/SGLIOQfZ/CoNv6BTlI6YEQ7Nj82oDVnRpwe/Z/F1EMx42x3JAOwGBlCjeCH0BRJQbQ/opHL17w== + dependencies: + "@types/unist" "^2.0.0" + character-entities "^2.0.0" + character-entities-legacy "^3.0.0" + character-reference-invalid "^2.0.0" + decode-named-character-reference "^1.0.0" + is-alphanumerical "^2.0.0" + is-decimal "^2.0.0" + is-hexadecimal "^2.0.0" + +parse-latin@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/parse-latin/-/parse-latin-7.0.0.tgz#8dfacac26fa603f76417f36233fc45602a323e1d" + integrity sha512-mhHgobPPua5kZ98EF4HWiH167JWBfl4pvAIXXdbaVohtK7a6YBOy56kvhCqduqyo/f3yrHFWmqmiMg/BkBkYYQ== + dependencies: + "@types/nlcst" "^2.0.0" + "@types/unist" "^3.0.0" + nlcst-to-string "^4.0.0" + unist-util-modify-children "^4.0.0" + unist-util-visit-children "^3.0.0" + vfile "^6.0.0" + +parse5@^7.0.0: + version "7.1.2" + resolved "https://registry.yarnpkg.com/parse5/-/parse5-7.1.2.tgz#0736bebbfd77793823240a23b7fc5e010b7f8e32" + integrity sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw== + dependencies: + entities "^4.4.0" + +path-browserify@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-1.0.1.tgz#d98454a9c3753d5790860f16f68867b9e46be1fd" + integrity sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g== + +path-exists@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3" + integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== + +periscopic@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/periscopic/-/periscopic-3.1.0.tgz#7e9037bf51c5855bd33b48928828db4afa79d97a" + integrity sha512-vKiQ8RRtkl9P+r/+oefh25C3fhybptkHKCZSPlcXiJux2tJF55GnEj3BVn4A5gKfq9NWWXXrxkHBwVPUfH0opw== + dependencies: + "@types/estree" "^1.0.0" + estree-walker "^3.0.0" + is-reference "^3.0.0" + +picocolors@^1.0.0, picocolors@^1.0.1, picocolors@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.1.0.tgz#5358b76a78cde483ba5cef6a9dc9671440b27d59" + integrity sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw== + +picomatch@4.0.2: + version "4.0.2" + resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-4.0.2.tgz#77c742931e8f3b8820946c76cd0c1f13730d1dab" + integrity sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg== + +picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1: + version "2.3.1" + resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42" + integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== + +pify@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231" + integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g== + +pkg-dir@^4.2.0: + version "4.2.0" + resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3" + integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ== + dependencies: + find-up "^4.0.0" + +postcss-nested@^6.0.1: + version "6.2.0" + resolved "https://registry.yarnpkg.com/postcss-nested/-/postcss-nested-6.2.0.tgz#4c2d22ab5f20b9cb61e2c5c5915950784d068131" + integrity sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ== + dependencies: + postcss-selector-parser "^6.1.1" + +postcss-selector-parser@^6.1.1: + version "6.1.2" + resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz#27ecb41fb0e3b6ba7a1ec84fff347f734c7929de" + integrity sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg== + dependencies: + cssesc "^3.0.0" + util-deprecate "^1.0.2" + +postcss@^8.4.38, postcss@^8.4.43: + version "8.4.47" + resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.4.47.tgz#5bf6c9a010f3e724c503bf03ef7947dcb0fea365" + integrity sha512-56rxCq7G/XfB4EkXq9Egn5GCqugWvDFjafDOThIdMBsI15iqPqR5r15TfSr1YPYeEI19YeaXMCbY6u88Y76GLQ== + dependencies: + nanoid "^3.3.7" + picocolors "^1.1.0" + source-map-js "^1.2.1" + +prebuild-install@^7.1.1: + version "7.1.2" + resolved "https://registry.yarnpkg.com/prebuild-install/-/prebuild-install-7.1.2.tgz#a5fd9986f5a6251fbc47e1e5c65de71e68c0a056" + integrity sha512-UnNke3IQb6sgarcZIDU3gbMeTp/9SSU1DAIkil7PrqG1vZlBtY5msYccSKSHDqa3hNg436IXK+SNImReuA1wEQ== + dependencies: + detect-libc "^2.0.0" + expand-template "^2.0.3" + github-from-package "0.0.0" + minimist "^1.2.3" + mkdirp-classic "^0.5.3" + napi-build-utils "^1.0.1" + node-abi "^3.3.0" + pump "^3.0.0" + rc "^1.2.7" + simple-get "^4.0.0" + tar-fs "^2.0.0" + tunnel-agent "^0.6.0" + +preferred-pm@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/preferred-pm/-/preferred-pm-4.0.0.tgz#6b256a44d39181fb3829b3abbd9ea2ead6db082b" + integrity sha512-gYBeFTZLu055D8Vv3cSPox/0iTPtkzxpLroSYYA7WXgRi31WCJ51Uyl8ZiPeUUjyvs2MBzK+S8v9JVUgHU/Sqw== + dependencies: + find-up-simple "^1.0.0" + find-yarn-workspace-root2 "1.2.16" + which-pm "^3.0.0" + +prettier@2.8.7: + version "2.8.7" + resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.7.tgz#bb79fc8729308549d28fe3a98fce73d2c0656450" + integrity sha512-yPngTo3aXUUmyuTjeTUT75txrf+aMh9FiD7q9ZE/i6r0bPb22g4FsE6Y338PQX1bmfy08i9QQCB7/rcUAVntfw== + +prismjs@^1.29.0: + version "1.29.0" + resolved "https://registry.yarnpkg.com/prismjs/-/prismjs-1.29.0.tgz#f113555a8fa9b57c35e637bba27509dcf802dd12" + integrity sha512-Kx/1w86q/epKcmte75LNrEoT+lX8pBpavuAbvJWRXar7Hz8jrtF+e3vY751p0R8H9HdArwaCTNDDzHg/ScJK1Q== + +prompts@^2.4.2: + version "2.4.2" + resolved "https://registry.yarnpkg.com/prompts/-/prompts-2.4.2.tgz#7b57e73b3a48029ad10ebd44f74b01722a4cb069" + integrity sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q== + dependencies: + kleur "^3.0.3" + sisteransi "^1.0.5" + +property-information@^6.0.0: + version "6.5.0" + resolved "https://registry.yarnpkg.com/property-information/-/property-information-6.5.0.tgz#6212fbb52ba757e92ef4fb9d657563b933b7ffec" + integrity sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig== + +pump@^3.0.0: + version "3.0.2" + resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.2.tgz#836f3edd6bc2ee599256c924ffe0d88573ddcbf8" + integrity sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw== + dependencies: + end-of-stream "^1.1.0" + once "^1.3.1" + +queue-microtask@^1.2.2: + version "1.2.3" + resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243" + integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A== + +queue-tick@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/queue-tick/-/queue-tick-1.0.1.tgz#f6f07ac82c1fd60f82e098b417a80e52f1f4c142" + integrity sha512-kJt5qhMxoszgU/62PLP1CJytzd2NKetjSRnyuj31fDd3Rlcz3fzlFdFLD1SItunPwyqEOkca6GbV612BWfaBag== + +rc@^1.2.7: + version "1.2.8" + resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.8.tgz#cd924bf5200a075b83c188cd6b9e211b7fc0d3ed" + integrity sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw== + dependencies: + deep-extend "^0.6.0" + ini "~1.3.0" + minimist "^1.2.0" + strip-json-comments "~2.0.1" + +readable-stream@^3.1.1, readable-stream@^3.4.0: + version "3.6.2" + resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.2.tgz#56a9b36ea965c00c5a93ef31eb111a0f11056967" + integrity sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA== + dependencies: + inherits "^2.0.3" + string_decoder "^1.1.1" + util-deprecate "^1.0.1" + +readdirp@~3.6.0: + version "3.6.0" + resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7" + integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA== + dependencies: + picomatch "^2.2.1" + +regenerator-runtime@^0.14.0: + version "0.14.1" + resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz#356ade10263f685dda125100cd862c1db895327f" + integrity sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw== + +regex@^4.3.2: + version "4.3.2" + resolved "https://registry.yarnpkg.com/regex/-/regex-4.3.2.tgz#a68a68c9b337a77bf4ce4ed0b4b1a49d97cb3b7b" + integrity sha512-kK/AA3A9K6q2js89+VMymcboLOlF5lZRCYJv3gzszXFHBr6kO6qLGzbm+UIugBEV8SMMKCTR59txoY6ctRHYVw== + +rehype-autolink-headings@7.1.0: + version "7.1.0" + resolved "https://registry.yarnpkg.com/rehype-autolink-headings/-/rehype-autolink-headings-7.1.0.tgz#531087e155d9df053944923efd47d99728f3b196" + integrity sha512-rItO/pSdvnvsP4QRB1pmPiNHUskikqtPojZKJPPPAVx9Hj8i8TwMBhofrrAYRhYOOBZH9tgmG5lPqDLuIWPWmw== + dependencies: + "@types/hast" "^3.0.0" + "@ungap/structured-clone" "^1.0.0" + hast-util-heading-rank "^3.0.0" + hast-util-is-element "^3.0.0" + unified "^11.0.0" + unist-util-visit "^5.0.0" + +rehype-expressive-code@^0.35.6: + version "0.35.6" + resolved "https://registry.yarnpkg.com/rehype-expressive-code/-/rehype-expressive-code-0.35.6.tgz#aacae31a68664b4055b4c969a69992787ace5307" + integrity sha512-pPdE+pRcRw01kxMOwHQjuRxgwlblZt5+wAc3w2aPGgmcnn57wYjn07iKO7zaznDxYVxMYVvYlnL+R3vWFQS4Gw== + dependencies: + expressive-code "^0.35.6" + +rehype-format@^5.0.0: + version "5.0.1" + resolved "https://registry.yarnpkg.com/rehype-format/-/rehype-format-5.0.1.tgz#e255e59bed0c062156aaf51c16fad5a521a1f5c8" + integrity sha512-zvmVru9uB0josBVpr946OR8ui7nJEdzZobwLOOqHb/OOD88W0Vk2SqLwoVOj0fM6IPCCO6TaV9CvQvJMWwukFQ== + dependencies: + "@types/hast" "^3.0.0" + hast-util-format "^1.0.0" + +rehype-katex@7.0.1: + version "7.0.1" + resolved "https://registry.yarnpkg.com/rehype-katex/-/rehype-katex-7.0.1.tgz#832e6d7af2744a228981d1b0fe89483a9e7c93a1" + integrity sha512-OiM2wrZ/wuhKkigASodFoo8wimG3H12LWQaH8qSPVJn9apWKFSH3YOCtbKpBorTVw/eI7cuT21XBbvwEswbIOA== + dependencies: + "@types/hast" "^3.0.0" + "@types/katex" "^0.16.0" + hast-util-from-html-isomorphic "^2.0.0" + hast-util-to-text "^4.0.0" + katex "^0.16.0" + unist-util-visit-parents "^6.0.0" + vfile "^6.0.0" + +rehype-parse@^9.0.0: + version "9.0.0" + resolved "https://registry.yarnpkg.com/rehype-parse/-/rehype-parse-9.0.0.tgz#3949faeec6f466ec57774215661e0d75469195d9" + integrity sha512-WG7nfvmWWkCR++KEkZevZb/uw41E8TsH4DsY9UxsTbIXCVGbAs4S+r8FrQ+OtH5EEQAs+5UxKC42VinkmpA1Yw== + dependencies: + "@types/hast" "^3.0.0" + hast-util-from-html "^2.0.0" + unified "^11.0.0" + +rehype-raw@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/rehype-raw/-/rehype-raw-7.0.0.tgz#59d7348fd5dbef3807bbaa1d443efd2dd85ecee4" + integrity sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww== + dependencies: + "@types/hast" "^3.0.0" + hast-util-raw "^9.0.0" + vfile "^6.0.0" + +rehype-stringify@^10.0.0: + version "10.0.0" + resolved "https://registry.yarnpkg.com/rehype-stringify/-/rehype-stringify-10.0.0.tgz#2031cf6fdd0355393706f0474ec794c75e5492f2" + integrity sha512-1TX1i048LooI9QoecrXy7nGFFbFSufxVRAfc6Y9YMRAi56l+oB0zP51mLSV312uRuvVLPV1opSlJmslozR1XHQ== + dependencies: + "@types/hast" "^3.0.0" + hast-util-to-html "^9.0.0" + unified "^11.0.0" + +rehype@^13.0.1: + version "13.0.1" + resolved "https://registry.yarnpkg.com/rehype/-/rehype-13.0.1.tgz#56384ba83955e2f3aa7eca1975b406c67d9dbd5e" + integrity sha512-AcSLS2mItY+0fYu9xKxOu1LhUZeBZZBx8//5HKzF+0XP+eP8+6a5MXn2+DW2kfXR6Dtp1FEXMVrjyKAcvcU8vg== + dependencies: + "@types/hast" "^3.0.0" + rehype-parse "^9.0.0" + rehype-stringify "^10.0.0" + unified "^11.0.0" + +remark-custom-heading-id@2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/remark-custom-heading-id/-/remark-custom-heading-id-2.0.0.tgz#9eecf63937cea189f9737df74059129906847efd" + integrity sha512-LpR+c4pmuBGG/zhNbebecDnpKyXU4B7bdNu6tXW83T3QWlkwUpHYyUR8uXQ/BERK9HlI5pXGLu7DjkIS07/iVQ== + dependencies: + mdast-heading-id "*" + micromark-heading-id "*" + unist-util-visit "^5.0.0" + +remark-directive@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/remark-directive/-/remark-directive-3.0.0.tgz#34452d951b37e6207d2e2a4f830dc33442923268" + integrity sha512-l1UyWJ6Eg1VPU7Hm/9tt0zKtReJQNOA4+iDMAxTyZNWnJnFlbS/7zhiel/rogTLQ2vMYwDzSJa4BiVNqGlqIMA== + dependencies: + "@types/mdast" "^4.0.0" + mdast-util-directive "^3.0.0" + micromark-extension-directive "^3.0.0" + unified "^11.0.0" + +remark-gfm@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/remark-gfm/-/remark-gfm-4.0.0.tgz#aea777f0744701aa288b67d28c43565c7e8c35de" + integrity sha512-U92vJgBPkbw4Zfu/IiW2oTZLSL3Zpv+uI7My2eq8JxKgqraFdU8YUGicEJCEgSbeaG+QDFqIcwwfMTOEelPxuA== + dependencies: + "@types/mdast" "^4.0.0" + mdast-util-gfm "^3.0.0" + micromark-extension-gfm "^3.0.0" + remark-parse "^11.0.0" + remark-stringify "^11.0.0" + unified "^11.0.0" + +remark-math@6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/remark-math/-/remark-math-6.0.0.tgz#0acdf74675f1c195fea6efffa78582f7ed7fc0d7" + integrity sha512-MMqgnP74Igy+S3WwnhQ7kqGlEerTETXMvJhrUzDikVZ2/uogJCb+WHUg97hK9/jcfc0dkD73s3LN8zU49cTEtA== + dependencies: + "@types/mdast" "^4.0.0" + mdast-util-math "^3.0.0" + micromark-extension-math "^3.0.0" + unified "^11.0.0" + +remark-mdx@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/remark-mdx/-/remark-mdx-3.0.1.tgz#8f73dd635c1874e44426e243f72c0977cf60e212" + integrity sha512-3Pz3yPQ5Rht2pM5R+0J2MrGoBSrzf+tJG94N+t/ilfdh8YLyyKYtidAYwTveB20BoHAcwIopOUqhcmh2F7hGYA== + dependencies: + mdast-util-mdx "^3.0.0" + micromark-extension-mdxjs "^3.0.0" + +remark-parse@^11.0.0: + version "11.0.0" + resolved "https://registry.yarnpkg.com/remark-parse/-/remark-parse-11.0.0.tgz#aa60743fcb37ebf6b069204eb4da304e40db45a1" + integrity sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA== + dependencies: + "@types/mdast" "^4.0.0" + mdast-util-from-markdown "^2.0.0" + micromark-util-types "^2.0.0" + unified "^11.0.0" + +remark-rehype@^11.0.0, remark-rehype@^11.1.0: + version "11.1.1" + resolved "https://registry.yarnpkg.com/remark-rehype/-/remark-rehype-11.1.1.tgz#f864dd2947889a11997c0a2667cd6b38f685bca7" + integrity sha512-g/osARvjkBXb6Wo0XvAeXQohVta8i84ACbenPpoSsxTOQH/Ae0/RGP4WZgnMH5pMLpsj4FG7OHmcIcXxpza8eQ== + dependencies: + "@types/hast" "^3.0.0" + "@types/mdast" "^4.0.0" + mdast-util-to-hast "^13.0.0" + unified "^11.0.0" + vfile "^6.0.0" + +remark-smartypants@^3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/remark-smartypants/-/remark-smartypants-3.0.2.tgz#cbaf2b39624c78fcbd6efa224678c1d2e9bc1dfb" + integrity sha512-ILTWeOriIluwEvPjv67v7Blgrcx+LZOkAUVtKI3putuhlZm84FnqDORNXPPm+HY3NdZOMhyDwZ1E+eZB/Df5dA== + dependencies: + retext "^9.0.0" + retext-smartypants "^6.0.0" + unified "^11.0.4" + unist-util-visit "^5.0.0" + +remark-stringify@^11.0.0: + version "11.0.0" + resolved "https://registry.yarnpkg.com/remark-stringify/-/remark-stringify-11.0.0.tgz#4c5b01dd711c269df1aaae11743eb7e2e7636fd3" + integrity sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw== + dependencies: + "@types/mdast" "^4.0.0" + mdast-util-to-markdown "^2.0.0" + unified "^11.0.0" + +repeat-string@^1.6.1: + version "1.6.1" + resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637" + integrity sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w== + +request-light@^0.5.7: + version "0.5.8" + resolved "https://registry.yarnpkg.com/request-light/-/request-light-0.5.8.tgz#8bf73a07242b9e7b601fac2fa5dc22a094abcc27" + integrity sha512-3Zjgh+8b5fhRJBQZoy+zbVKpAQGLyka0MPgW3zruTF4dFFJ8Fqcfu9YsAvi/rvdcaTeWG3MkbZv4WKxAn/84Lg== + +request-light@^0.7.0: + version "0.7.0" + resolved "https://registry.yarnpkg.com/request-light/-/request-light-0.7.0.tgz#885628bb2f8040c26401ebf258ec51c4ae98ac2a" + integrity sha512-lMbBMrDoxgsyO+yB3sDcrDuX85yYt7sS8BfQd11jtbW/z5ZWgLZRcEGLsLoYw7I0WSUGQBs8CC8ScIxkTX1+6Q== + +require-directory@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42" + integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== + +require-from-string@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909" + integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw== + +resolve-from@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6" + integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g== + +resolve-from@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69" + integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw== + +restore-cursor@^5.0.0: + version "5.1.0" + resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-5.1.0.tgz#0766d95699efacb14150993f55baf0953ea1ebe7" + integrity sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA== + dependencies: + onetime "^7.0.0" + signal-exit "^4.1.0" + +retext-latin@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/retext-latin/-/retext-latin-4.0.0.tgz#d02498aa1fd39f1bf00e2ff59b1384c05d0c7ce3" + integrity sha512-hv9woG7Fy0M9IlRQloq/N6atV82NxLGveq+3H2WOi79dtIYWN8OaxogDm77f8YnVXJL2VD3bbqowu5E3EMhBYA== + dependencies: + "@types/nlcst" "^2.0.0" + parse-latin "^7.0.0" + unified "^11.0.0" + +retext-smartypants@^6.0.0: + version "6.1.1" + resolved "https://registry.yarnpkg.com/retext-smartypants/-/retext-smartypants-6.1.1.tgz#6f57e71c889510d9c322ceb61038908ffabd31d0" + integrity sha512-onsHf34i/GzgElJgtT1K2V+31yEhWs7NJboKNxXJcmVMMPxLpgxZ9iADoMdydd6j/bHic5F/aNq0CGqElEtu2g== + dependencies: + "@types/nlcst" "^2.0.0" + nlcst-to-string "^4.0.0" + unist-util-visit "^5.0.0" + +retext-stringify@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/retext-stringify/-/retext-stringify-4.0.0.tgz#501d5440bd4d121e351c7c509f8507de9611e159" + integrity sha512-rtfN/0o8kL1e+78+uxPTqu1Klt0yPzKuQ2BfWwwfgIUSayyzxpM1PJzkKt4V8803uB9qSy32MvI7Xep9khTpiA== + dependencies: + "@types/nlcst" "^2.0.0" + nlcst-to-string "^4.0.0" + unified "^11.0.0" + +retext@^9.0.0: + version "9.0.0" + resolved "https://registry.yarnpkg.com/retext/-/retext-9.0.0.tgz#ab5cd72836894167b0ca6ae70fdcfaa166267f7a" + integrity sha512-sbMDcpHCNjvlheSgMfEcVrZko3cDzdbe1x/e7G66dFp0Ff7Mldvi2uv6JkJQzdRcvLYE8CA8Oe8siQx8ZOgTcA== + dependencies: + "@types/nlcst" "^2.0.0" + retext-latin "^4.0.0" + retext-stringify "^4.0.0" + unified "^11.0.0" + +reusify@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76" + integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw== + +rollup@^4.20.0: + version "4.22.0" + resolved "https://registry.yarnpkg.com/rollup/-/rollup-4.22.0.tgz#23cd9e4565a458587683accc34a054660c01f351" + integrity sha512-W21MUIFPZ4+O2Je/EU+GP3iz7PH4pVPUXSbEZdatQnxo29+3rsUjgrJmzuAZU24z7yRAnFN6ukxeAhZh/c7hzg== + dependencies: + "@types/estree" "1.0.5" + optionalDependencies: + "@rollup/rollup-android-arm-eabi" "4.22.0" + "@rollup/rollup-android-arm64" "4.22.0" + "@rollup/rollup-darwin-arm64" "4.22.0" + "@rollup/rollup-darwin-x64" "4.22.0" + "@rollup/rollup-linux-arm-gnueabihf" "4.22.0" + "@rollup/rollup-linux-arm-musleabihf" "4.22.0" + "@rollup/rollup-linux-arm64-gnu" "4.22.0" + "@rollup/rollup-linux-arm64-musl" "4.22.0" + "@rollup/rollup-linux-powerpc64le-gnu" "4.22.0" + "@rollup/rollup-linux-riscv64-gnu" "4.22.0" + "@rollup/rollup-linux-s390x-gnu" "4.22.0" + "@rollup/rollup-linux-x64-gnu" "4.22.0" + "@rollup/rollup-linux-x64-musl" "4.22.0" + "@rollup/rollup-win32-arm64-msvc" "4.22.0" + "@rollup/rollup-win32-ia32-msvc" "4.22.0" + "@rollup/rollup-win32-x64-msvc" "4.22.0" + fsevents "~2.3.2" + +run-parallel@^1.1.9: + version "1.2.0" + resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee" + integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA== + dependencies: + queue-microtask "^1.2.2" + +safe-buffer@^5.0.1, safe-buffer@~5.2.0: + version "5.2.1" + resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6" + integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== + +sax@^1.2.4: + version "1.4.1" + resolved "https://registry.yarnpkg.com/sax/-/sax-1.4.1.tgz#44cc8988377f126304d3b3fc1010c733b929ef0f" + integrity sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg== + +section-matter@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/section-matter/-/section-matter-1.0.0.tgz#e9041953506780ec01d59f292a19c7b850b84167" + integrity sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA== + dependencies: + extend-shallow "^2.0.1" + kind-of "^6.0.0" + +semver@^6.3.1: + version "6.3.1" + resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4" + integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA== + +semver@^7.3.5, semver@^7.3.8, semver@^7.5.4, semver@^7.6.2, semver@^7.6.3: + version "7.6.3" + resolved "https://registry.yarnpkg.com/semver/-/semver-7.6.3.tgz#980f7b5550bc175fb4dc09403085627f9eb33143" + integrity sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A== + +sharp@^0.32.5: + version "0.32.6" + resolved "https://registry.yarnpkg.com/sharp/-/sharp-0.32.6.tgz#6ad30c0b7cd910df65d5f355f774aa4fce45732a" + integrity sha512-KyLTWwgcR9Oe4d9HwCwNM2l7+J0dUQwn/yf7S0EnTtb0eVS4RxO0eUSvxPtzT4F3SY+C4K6fqdv/DO27sJ/v/w== + dependencies: + color "^4.2.3" + detect-libc "^2.0.2" + node-addon-api "^6.1.0" + prebuild-install "^7.1.1" + semver "^7.5.4" + simple-get "^4.0.1" + tar-fs "^3.0.4" + tunnel-agent "^0.6.0" + +sharp@^0.33.3: + version "0.33.5" + resolved "https://registry.yarnpkg.com/sharp/-/sharp-0.33.5.tgz#13e0e4130cc309d6a9497596715240b2ec0c594e" + integrity sha512-haPVm1EkS9pgvHrQ/F3Xy+hgcuMV0Wm9vfIBSiwZ05k+xgb0PkBQpGsAA/oWdDobNaZTH5ppvHtzCFbnSEwHVw== + dependencies: + color "^4.2.3" + detect-libc "^2.0.3" + semver "^7.6.3" + optionalDependencies: + "@img/sharp-darwin-arm64" "0.33.5" + "@img/sharp-darwin-x64" "0.33.5" + "@img/sharp-libvips-darwin-arm64" "1.0.4" + "@img/sharp-libvips-darwin-x64" "1.0.4" + "@img/sharp-libvips-linux-arm" "1.0.5" + "@img/sharp-libvips-linux-arm64" "1.0.4" + "@img/sharp-libvips-linux-s390x" "1.0.4" + "@img/sharp-libvips-linux-x64" "1.0.4" + "@img/sharp-libvips-linuxmusl-arm64" "1.0.4" + "@img/sharp-libvips-linuxmusl-x64" "1.0.4" + "@img/sharp-linux-arm" "0.33.5" + "@img/sharp-linux-arm64" "0.33.5" + "@img/sharp-linux-s390x" "0.33.5" + "@img/sharp-linux-x64" "0.33.5" + "@img/sharp-linuxmusl-arm64" "0.33.5" + "@img/sharp-linuxmusl-x64" "0.33.5" + "@img/sharp-wasm32" "0.33.5" + "@img/sharp-win32-ia32" "0.33.5" + "@img/sharp-win32-x64" "0.33.5" + +shiki@^1.1.7, shiki@^1.10.3, shiki@^1.16.2: + version "1.18.0" + resolved "https://registry.yarnpkg.com/shiki/-/shiki-1.18.0.tgz#4f9ca2f442b3612849017ab1dcac47c35ee52276" + integrity sha512-8jo7tOXr96h9PBQmOHVrltnETn1honZZY76YA79MHheGQg55jBvbm9dtU+MI5pjC5NJCFuA6rvVTLVeSW5cE4A== + dependencies: + "@shikijs/core" "1.18.0" + "@shikijs/engine-javascript" "1.18.0" + "@shikijs/engine-oniguruma" "1.18.0" + "@shikijs/types" "1.18.0" + "@shikijs/vscode-textmate" "^9.2.2" + "@types/hast" "^3.0.4" + +signal-exit@^4.1.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-4.1.0.tgz#952188c1cbd546070e2dd20d0f41c0ae0530cb04" + integrity sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw== + +simple-concat@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/simple-concat/-/simple-concat-1.0.1.tgz#f46976082ba35c2263f1c8ab5edfe26c41c9552f" + integrity sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q== + +simple-get@^4.0.0, simple-get@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/simple-get/-/simple-get-4.0.1.tgz#4a39db549287c979d352112fa03fd99fd6bc3543" + integrity sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA== + dependencies: + decompress-response "^6.0.0" + once "^1.3.1" + simple-concat "^1.0.0" + +simple-swizzle@^0.2.2: + version "0.2.2" + resolved "https://registry.yarnpkg.com/simple-swizzle/-/simple-swizzle-0.2.2.tgz#a4da6b635ffcccca33f70d17cb92592de95e557a" + integrity sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg== + dependencies: + is-arrayish "^0.3.1" + +sisteransi@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed" + integrity sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg== + +sitemap@^7.1.2: + version "7.1.2" + resolved "https://registry.yarnpkg.com/sitemap/-/sitemap-7.1.2.tgz#6ce1deb43f6f177c68bc59cf93632f54e3ae6b72" + integrity sha512-ARCqzHJ0p4gWt+j7NlU5eDlIO9+Rkr/JhPFZKKQ1l5GCus7rJH4UdrlVAh0xC/gDS/Qir2UMxqYNHtsKr2rpCw== + dependencies: + "@types/node" "^17.0.5" + "@types/sax" "^1.2.1" + arg "^5.0.0" + sax "^1.2.4" + +source-map-js@^1.2.0, source-map-js@^1.2.1: + version "1.2.1" + resolved "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.2.1.tgz#1ce5650fddd87abc099eda37dcff024c2667ae46" + integrity sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA== + +source-map@^0.7.0, source-map@^0.7.4: + version "0.7.4" + resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.4.tgz#a9bbe705c9d8846f4e08ff6765acf0f1b0898656" + integrity sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA== + +space-separated-tokens@^2.0.0: + version "2.0.2" + resolved "https://registry.yarnpkg.com/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz#1ecd9d2350a3844572c3f4a312bceb018348859f" + integrity sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q== + +sprintf-js@~1.0.2: + version "1.0.3" + resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c" + integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g== + +starlight-links-validator@^0.12.1: + version "0.12.1" + resolved "https://registry.yarnpkg.com/starlight-links-validator/-/starlight-links-validator-0.12.1.tgz#e37b15488ad4a29d18dbd4602e47c25c378ea9bb" + integrity sha512-LhRuGaI9Rp7c7ltwcG0BfCZuAN1d15oYbDB4jXblJ6zsiFcrSGHNlDnKXJHEJZ6XhJ+eOpd1IsHLFLh5Sq6uHg== + dependencies: + "@types/picomatch" "2.3.3" + github-slugger "2.0.0" + hast-util-from-html "2.0.1" + hast-util-has-property "3.0.0" + is-absolute-url "4.0.1" + kleur "4.1.5" + mdast-util-to-string "4.0.0" + picomatch "4.0.2" + unist-util-visit "5.0.0" + +stdin-discarder@^0.2.2: + version "0.2.2" + resolved "https://registry.yarnpkg.com/stdin-discarder/-/stdin-discarder-0.2.2.tgz#390037f44c4ae1a1ae535c5fe38dc3aba8d997be" + integrity sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ== + +stream-replace-string@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/stream-replace-string/-/stream-replace-string-2.0.0.tgz#e49fd584bd1c633613e010bc73b9db49cb5024ad" + integrity sha512-TlnjJ1C0QrmxRNrON00JvaFFlNh5TTG00APw23j74ET7gkQpTASi6/L2fuiav8pzK715HXtUeClpBTw2NPSn6w== + +streamx@^2.15.0, streamx@^2.20.0: + version "2.20.1" + resolved "https://registry.yarnpkg.com/streamx/-/streamx-2.20.1.tgz#471c4f8b860f7b696feb83d5b125caab2fdbb93c" + integrity sha512-uTa0mU6WUC65iUvzKH4X9hEdvSW7rbPxPtwfWiLMSj3qTdQbAiUboZTxauKfpFuGIGa1C2BYijZ7wgdUXICJhA== + dependencies: + fast-fifo "^1.3.2" + queue-tick "^1.0.1" + text-decoder "^1.1.0" + optionalDependencies: + bare-events "^2.2.0" + +string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: + version "4.2.3" + resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== + dependencies: + emoji-regex "^8.0.0" + is-fullwidth-code-point "^3.0.0" + strip-ansi "^6.0.1" + +string-width@^5.0.1, string-width@^5.1.2: + version "5.1.2" + resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794" + integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA== + dependencies: + eastasianwidth "^0.2.0" + emoji-regex "^9.2.2" + strip-ansi "^7.0.1" + +string-width@^7.2.0: + version "7.2.0" + resolved "https://registry.yarnpkg.com/string-width/-/string-width-7.2.0.tgz#b5bb8e2165ce275d4d43476dd2700ad9091db6dc" + integrity sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ== + dependencies: + emoji-regex "^10.3.0" + get-east-asian-width "^1.0.0" + strip-ansi "^7.1.0" + +string_decoder@^1.1.1: + version "1.3.0" + resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e" + integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA== + dependencies: + safe-buffer "~5.2.0" + +stringify-entities@^4.0.0: + version "4.0.4" + resolved "https://registry.yarnpkg.com/stringify-entities/-/stringify-entities-4.0.4.tgz#b3b79ef5f277cc4ac73caeb0236c5ba939b3a4f3" + integrity sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg== + dependencies: + character-entities-html4 "^2.0.0" + character-entities-legacy "^3.0.0" + +strip-ansi@^6.0.0, strip-ansi@^6.0.1: + version "6.0.1" + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== + dependencies: + ansi-regex "^5.0.1" + +strip-ansi@^7.0.1, strip-ansi@^7.1.0: + version "7.1.0" + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.1.0.tgz#d5b6568ca689d8561370b0707685d22434faff45" + integrity sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ== + dependencies: + ansi-regex "^6.0.1" + +strip-bom-string@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/strip-bom-string/-/strip-bom-string-1.0.0.tgz#e5211e9224369fbb81d633a2f00044dc8cedad92" + integrity sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g== + +strip-bom@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3" + integrity sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA== + +strip-json-comments@~2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a" + integrity sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ== + +style-to-object@^0.4.0: + version "0.4.4" + resolved "https://registry.yarnpkg.com/style-to-object/-/style-to-object-0.4.4.tgz#266e3dfd56391a7eefb7770423612d043c3f33ec" + integrity sha512-HYNoHZa2GorYNyqiCaBgsxvcJIn7OHq6inEga+E6Ke3m5JkoqpQbnFssk4jwe+K7AhGa2fcha4wSOf1Kn01dMg== + dependencies: + inline-style-parser "0.1.1" + +style-to-object@^1.0.0: + version "1.0.8" + resolved "https://registry.yarnpkg.com/style-to-object/-/style-to-object-1.0.8.tgz#67a29bca47eaa587db18118d68f9d95955e81292" + integrity sha512-xT47I/Eo0rwJmaXC4oilDGDWLohVhR6o/xAQcPQN8q6QBuZVL8qMYL85kLmST5cPjAorwvqIA4qXTRQoYHaL6g== + dependencies: + inline-style-parser "0.2.4" + +supports-color@^5.3.0: + version "5.5.0" + resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f" + integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow== + dependencies: + has-flag "^3.0.0" + +tar-fs@^2.0.0: + version "2.1.1" + resolved "https://registry.yarnpkg.com/tar-fs/-/tar-fs-2.1.1.tgz#489a15ab85f1f0befabb370b7de4f9eb5cbe8784" + integrity sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng== + dependencies: + chownr "^1.1.1" + mkdirp-classic "^0.5.2" + pump "^3.0.0" + tar-stream "^2.1.4" + +tar-fs@^3.0.4: + version "3.0.6" + resolved "https://registry.yarnpkg.com/tar-fs/-/tar-fs-3.0.6.tgz#eaccd3a67d5672f09ca8e8f9c3d2b89fa173f217" + integrity sha512-iokBDQQkUyeXhgPYaZxmczGPhnhXZ0CmrqI+MOb/WFGS9DW5wnfrLgtjUJBvz50vQ3qfRwJ62QVoCFu8mPVu5w== + dependencies: + pump "^3.0.0" + tar-stream "^3.1.5" + optionalDependencies: + bare-fs "^2.1.1" + bare-path "^2.1.0" + +tar-stream@^2.1.4: + version "2.2.0" + resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-2.2.0.tgz#acad84c284136b060dc3faa64474aa9aebd77287" + integrity sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ== + dependencies: + bl "^4.0.3" + end-of-stream "^1.4.1" + fs-constants "^1.0.0" + inherits "^2.0.3" + readable-stream "^3.1.1" + +tar-stream@^3.1.5: + version "3.1.7" + resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-3.1.7.tgz#24b3fb5eabada19fe7338ed6d26e5f7c482e792b" + integrity sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ== + dependencies: + b4a "^1.6.4" + fast-fifo "^1.2.0" + streamx "^2.15.0" + +text-decoder@^1.1.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/text-decoder/-/text-decoder-1.2.0.tgz#85f19d4d5088e0b45cd841bdfaeac458dbffeefc" + integrity sha512-n1yg1mOj9DNpk3NeZOx7T6jchTbyJS3i3cucbNN6FcdPriMZx7NsgrGpWWdWZZGxD7ES1XB+3uoqHMgOKaN+fg== + dependencies: + b4a "^1.6.4" + +tinyexec@^0.3.0: + version "0.3.0" + resolved "https://registry.yarnpkg.com/tinyexec/-/tinyexec-0.3.0.tgz#ed60cfce19c17799d4a241e06b31b0ec2bee69e6" + integrity sha512-tVGE0mVJPGb0chKhqmsoosjsS+qUnJVGJpZgsHYQcGoPlG3B51R3PouqTgEGH2Dc9jjFyOqOpix6ZHNMXp1FZg== + +to-fast-properties@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e" + integrity sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog== + +to-regex-range@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4" + integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== + dependencies: + is-number "^7.0.0" + +trim-lines@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/trim-lines/-/trim-lines-3.0.1.tgz#d802e332a07df861c48802c04321017b1bd87338" + integrity sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg== + +trough@^2.0.0: + version "2.2.0" + resolved "https://registry.yarnpkg.com/trough/-/trough-2.2.0.tgz#94a60bd6bd375c152c1df911a4b11d5b0256f50f" + integrity sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw== + +tsconfck@^3.1.3: + version "3.1.3" + resolved "https://registry.yarnpkg.com/tsconfck/-/tsconfck-3.1.3.tgz#a8202f51dab684c426314796cdb0bbd0fe0cdf80" + integrity sha512-ulNZP1SVpRDesxeMLON/LtWM8HIgAJEIVpVVhBM6gsmvQ8+Rh+ZG7FWGvHh7Ah3pRABwVJWklWCr/BTZSv0xnQ== + +tslib@^2.4.0: + version "2.7.0" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.7.0.tgz#d9b40c5c40ab59e8738f297df3087bf1a2690c01" + integrity sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA== + +tunnel-agent@^0.6.0: + version "0.6.0" + resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd" + integrity sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w== + dependencies: + safe-buffer "^5.0.1" + +type-fest@^2.13.0: + version "2.19.0" + resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-2.19.0.tgz#88068015bb33036a598b952e55e9311a60fd3a9b" + integrity sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA== + +typesafe-path@^0.2.2: + version "0.2.2" + resolved "https://registry.yarnpkg.com/typesafe-path/-/typesafe-path-0.2.2.tgz#91a436681b2f514badb114061b6a5e5c2b8943b1" + integrity sha512-OJabfkAg1WLZSqJAJ0Z6Sdt3utnbzr/jh+NAHoyWHJe8CMSy79Gm085094M9nvTPy22KzTVn5Zq5mbapCI/hPA== + +typescript-auto-import-cache@^0.3.3: + version "0.3.3" + resolved "https://registry.yarnpkg.com/typescript-auto-import-cache/-/typescript-auto-import-cache-0.3.3.tgz#45f376313d1eb0929ce47ef1d1aae5a353d060a3" + integrity sha512-ojEC7+Ci1ij9eE6hp8Jl9VUNnsEKzztktP5gtYNRMrTmfXVwA1PITYYAkpxCvvupdSYa/Re51B6KMcv1CTZEUA== + dependencies: + semver "^7.3.8" + +typescript@^5.6.2: + version "5.6.2" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.6.2.tgz#d1de67b6bef77c41823f822df8f0b3bcff60a5a0" + integrity sha512-NW8ByodCSNCwZeghjN3o+JX5OFH0Ojg6sadjEKY4huZ52TqbJTJnDo5+Tw98lSy63NZvi4n+ez5m2u5d4PkZyw== + +undici-types@~6.19.2: + version "6.19.8" + resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-6.19.8.tgz#35111c9d1437ab83a7cdc0abae2f26d88eda0a02" + integrity sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw== + +unified@^11.0.0, unified@^11.0.4, unified@^11.0.5: + version "11.0.5" + resolved "https://registry.yarnpkg.com/unified/-/unified-11.0.5.tgz#f66677610a5c0a9ee90cab2b8d4d66037026d9e1" + integrity sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA== + dependencies: + "@types/unist" "^3.0.0" + bail "^2.0.0" + devlop "^1.0.0" + extend "^3.0.0" + is-plain-obj "^4.0.0" + trough "^2.0.0" + vfile "^6.0.0" + +unist-util-find-after@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/unist-util-find-after/-/unist-util-find-after-5.0.0.tgz#3fccc1b086b56f34c8b798e1ff90b5c54468e896" + integrity sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ== + dependencies: + "@types/unist" "^3.0.0" + unist-util-is "^6.0.0" + +unist-util-is@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/unist-util-is/-/unist-util-is-6.0.0.tgz#b775956486aff107a9ded971d996c173374be424" + integrity sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw== + dependencies: + "@types/unist" "^3.0.0" + +unist-util-modify-children@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/unist-util-modify-children/-/unist-util-modify-children-4.0.0.tgz#981d6308e887b005d1f491811d3cbcc254b315e9" + integrity sha512-+tdN5fGNddvsQdIzUF3Xx82CU9sMM+fA0dLgR9vOmT0oPT2jH+P1nd5lSqfCfXAw+93NhcXNY2qqvTUtE4cQkw== + dependencies: + "@types/unist" "^3.0.0" + array-iterate "^2.0.0" + +unist-util-position-from-estree@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/unist-util-position-from-estree/-/unist-util-position-from-estree-2.0.0.tgz#d94da4df596529d1faa3de506202f0c9a23f2200" + integrity sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ== + dependencies: + "@types/unist" "^3.0.0" + +unist-util-position@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/unist-util-position/-/unist-util-position-5.0.0.tgz#678f20ab5ca1207a97d7ea8a388373c9cf896be4" + integrity sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA== + dependencies: + "@types/unist" "^3.0.0" + +unist-util-remove-position@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/unist-util-remove-position/-/unist-util-remove-position-5.0.0.tgz#fea68a25658409c9460408bc6b4991b965b52163" + integrity sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q== + dependencies: + "@types/unist" "^3.0.0" + unist-util-visit "^5.0.0" + +unist-util-stringify-position@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz#449c6e21a880e0855bf5aabadeb3a740314abac2" + integrity sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ== + dependencies: + "@types/unist" "^3.0.0" + +unist-util-visit-children@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/unist-util-visit-children/-/unist-util-visit-children-3.0.0.tgz#4bced199b71d7f3c397543ea6cc39e7a7f37dc7e" + integrity sha512-RgmdTfSBOg04sdPcpTSD1jzoNBjt9a80/ZCzp5cI9n1qPzLZWF9YdvWGN2zmTumP1HWhXKdUWexjy/Wy/lJ7tA== + dependencies: + "@types/unist" "^3.0.0" + +unist-util-visit-parents@^6.0.0, unist-util-visit-parents@^6.0.1: + version "6.0.1" + resolved "https://registry.yarnpkg.com/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz#4d5f85755c3b8f0dc69e21eca5d6d82d22162815" + integrity sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw== + dependencies: + "@types/unist" "^3.0.0" + unist-util-is "^6.0.0" + +unist-util-visit@5.0.0, unist-util-visit@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/unist-util-visit/-/unist-util-visit-5.0.0.tgz#a7de1f31f72ffd3519ea71814cccf5fd6a9217d6" + integrity sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg== + dependencies: + "@types/unist" "^3.0.0" + unist-util-is "^6.0.0" + unist-util-visit-parents "^6.0.0" + +update-browserslist-db@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.1.0.tgz#7ca61c0d8650766090728046e416a8cde682859e" + integrity sha512-EdRAaAyk2cUE1wOf2DkEhzxqOQvFOoRJFNS6NeyJ01Gp2beMRpBAINjM2iDXE3KCuKhwnvHIQCJm6ThL2Z+HzQ== + dependencies: + escalade "^3.1.2" + picocolors "^1.0.1" + +util-deprecate@^1.0.1, util-deprecate@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf" + integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw== + +vfile-location@^5.0.0: + version "5.0.3" + resolved "https://registry.yarnpkg.com/vfile-location/-/vfile-location-5.0.3.tgz#cb9eacd20f2b6426d19451e0eafa3d0a846225c3" + integrity sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg== + dependencies: + "@types/unist" "^3.0.0" + vfile "^6.0.0" + +vfile-message@^4.0.0: + version "4.0.2" + resolved "https://registry.yarnpkg.com/vfile-message/-/vfile-message-4.0.2.tgz#c883c9f677c72c166362fd635f21fc165a7d1181" + integrity sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw== + dependencies: + "@types/unist" "^3.0.0" + unist-util-stringify-position "^4.0.0" + +vfile@^6.0.0, vfile@^6.0.2, vfile@^6.0.3: + version "6.0.3" + resolved "https://registry.yarnpkg.com/vfile/-/vfile-6.0.3.tgz#3652ab1c496531852bf55a6bac57af981ebc38ab" + integrity sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q== + dependencies: + "@types/unist" "^3.0.0" + vfile-message "^4.0.0" + +vite@^5.4.3: + version "5.4.6" + resolved "https://registry.yarnpkg.com/vite/-/vite-5.4.6.tgz#85a93a1228a7fb5a723ca1743e337a2588ed008f" + integrity sha512-IeL5f8OO5nylsgzd9tq4qD2QqI0k2CQLGrWD0rCN0EQJZpBK5vJAx0I+GDkMOXxQX/OfFHMuLIx6ddAxGX/k+Q== + dependencies: + esbuild "^0.21.3" + postcss "^8.4.43" + rollup "^4.20.0" + optionalDependencies: + fsevents "~2.3.3" + +vitefu@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/vitefu/-/vitefu-1.0.2.tgz#fbe9f7c7478be51678214bf468d7296ce29bf8ff" + integrity sha512-0/iAvbXyM3RiPPJ4lyD4w6Mjgtf4ejTK6TPvTNG3H32PLwuT0N/ZjJLiXug7ETE/LWtTeHw9WRv7uX/tIKYyKg== + +volar-service-css@0.0.61: + version "0.0.61" + resolved "https://registry.yarnpkg.com/volar-service-css/-/volar-service-css-0.0.61.tgz#848bae953c023337795fba4b9fb78fd3a5a759c3" + integrity sha512-Ct9L/w+IB1JU8F4jofcNCGoHy6TF83aiapfZq9A0qYYpq+Kk5dH+ONS+rVZSsuhsunq8UvAuF8Gk6B8IFLfniw== + dependencies: + vscode-css-languageservice "^6.3.0" + vscode-languageserver-textdocument "^1.0.11" + vscode-uri "^3.0.8" + +volar-service-emmet@0.0.61: + version "0.0.61" + resolved "https://registry.yarnpkg.com/volar-service-emmet/-/volar-service-emmet-0.0.61.tgz#298a3ffa04d02ba52885370f58d7a9c442fdda91" + integrity sha512-iiYqBxjjcekqrRruw4COQHZME6EZYWVbkHjHDbULpml3g8HGJHzpAMkj9tXNCPxf36A+f1oUYjsvZt36qPg4cg== + dependencies: + "@emmetio/css-parser" "^0.4.0" + "@emmetio/html-matcher" "^1.3.0" + "@vscode/emmet-helper" "^2.9.3" + vscode-uri "^3.0.8" + +volar-service-html@0.0.61: + version "0.0.61" + resolved "https://registry.yarnpkg.com/volar-service-html/-/volar-service-html-0.0.61.tgz#e57de0afcee8019aafe5ab3851cb609765a1a18a" + integrity sha512-yFE+YmmgqIL5HI4ORqP++IYb1QaGcv+xBboI0WkCxJJ/M35HZj7f5rbT3eQ24ECLXFbFCFanckwyWJVz5KmN3Q== + dependencies: + vscode-html-languageservice "^5.3.0" + vscode-languageserver-textdocument "^1.0.11" + vscode-uri "^3.0.8" + +volar-service-prettier@0.0.61: + version "0.0.61" + resolved "https://registry.yarnpkg.com/volar-service-prettier/-/volar-service-prettier-0.0.61.tgz#c32ddac86ac5d05d443b24fbe2d1172a58fa7cee" + integrity sha512-F612nql5I0IS8HxXemCGvOR2Uxd4XooIwqYVUvk7WSBxP/+xu1jYvE3QJ7EVpl8Ty3S4SxPXYiYTsG3bi+gzIQ== + dependencies: + vscode-uri "^3.0.8" + +volar-service-typescript-twoslash-queries@0.0.61: + version "0.0.61" + resolved "https://registry.yarnpkg.com/volar-service-typescript-twoslash-queries/-/volar-service-typescript-twoslash-queries-0.0.61.tgz#1dbcfa92985e5e680b9f1e9c69dda03f7e7df6dd" + integrity sha512-99FICGrEF0r1E2tV+SvprHPw9Knyg7BdW2fUch0tf59kG+KG+Tj4tL6tUg+cy8f23O/VXlmsWFMIE+bx1dXPnQ== + dependencies: + vscode-uri "^3.0.8" + +volar-service-typescript@0.0.61: + version "0.0.61" + resolved "https://registry.yarnpkg.com/volar-service-typescript/-/volar-service-typescript-0.0.61.tgz#5c4572e34b11f57fe7087fd7242617f21eec25c5" + integrity sha512-4kRHxVbW7wFBHZWRU6yWxTgiKETBDIJNwmJUAWeP0mHaKpnDGj/astdRFKqGFRYVeEYl45lcUPhdJyrzanjsdQ== + dependencies: + path-browserify "^1.0.1" + semver "^7.6.2" + typescript-auto-import-cache "^0.3.3" + vscode-languageserver-textdocument "^1.0.11" + vscode-nls "^5.2.0" + vscode-uri "^3.0.8" + +volar-service-yaml@0.0.61: + version "0.0.61" + resolved "https://registry.yarnpkg.com/volar-service-yaml/-/volar-service-yaml-0.0.61.tgz#f4f11af9c29bdacb125e207410b07c84890c925d" + integrity sha512-L+gbDiLDQQ1rZUbJ3mf3doDsoQUa8OZM/xdpk/unMg1Vz24Zmi2Ign8GrZyBD7bRoIQDwOH9gdktGDKzRPpUNw== + dependencies: + vscode-uri "^3.0.8" + yaml-language-server "~1.15.0" + +vscode-css-languageservice@^6.3.0: + version "6.3.1" + resolved "https://registry.yarnpkg.com/vscode-css-languageservice/-/vscode-css-languageservice-6.3.1.tgz#56733c90686db56855ccc156a534a68b8c1f2187" + integrity sha512-1BzTBuJfwMc3A0uX4JBdJgoxp74cjj4q2mDJdp49yD/GuAq4X0k5WtK6fNcMYr+FfJ9nqgR6lpfCSZDkARJ5qQ== + dependencies: + "@vscode/l10n" "^0.0.18" + vscode-languageserver-textdocument "^1.0.12" + vscode-languageserver-types "3.17.5" + vscode-uri "^3.0.8" + +vscode-html-languageservice@^5.2.0, vscode-html-languageservice@^5.3.0: + version "5.3.1" + resolved "https://registry.yarnpkg.com/vscode-html-languageservice/-/vscode-html-languageservice-5.3.1.tgz#93cac1cebb42165b52a15220f02c47d1320fc43a" + integrity sha512-ysUh4hFeW/WOWz/TO9gm08xigiSsV/FOAZ+DolgJfeLftna54YdmZ4A+lIn46RbdO3/Qv5QHTn1ZGqmrXQhZyA== + dependencies: + "@vscode/l10n" "^0.0.18" + vscode-languageserver-textdocument "^1.0.12" + vscode-languageserver-types "^3.17.5" + vscode-uri "^3.0.8" + +vscode-json-languageservice@4.1.8: + version "4.1.8" + resolved "https://registry.yarnpkg.com/vscode-json-languageservice/-/vscode-json-languageservice-4.1.8.tgz#397a39238d496e3e08a544a8b93df2cd13347d0c" + integrity sha512-0vSpg6Xd9hfV+eZAaYN63xVVMOTmJ4GgHxXnkLCh+9RsQBkWKIghzLhW2B9ebfG+LQQg8uLtsQ2aUKjTgE+QOg== + dependencies: + jsonc-parser "^3.0.0" + vscode-languageserver-textdocument "^1.0.1" + vscode-languageserver-types "^3.16.0" + vscode-nls "^5.0.0" + vscode-uri "^3.0.2" + +vscode-jsonrpc@6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/vscode-jsonrpc/-/vscode-jsonrpc-6.0.0.tgz#108bdb09b4400705176b957ceca9e0880e9b6d4e" + integrity sha512-wnJA4BnEjOSyFMvjZdpiOwhSq9uDoK8e/kpRJDTaMYzwlkrhG1fwDIZI94CLsLzlCK5cIbMMtFlJlfR57Lavmg== + +vscode-jsonrpc@8.2.0: + version "8.2.0" + resolved "https://registry.yarnpkg.com/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz#f43dfa35fb51e763d17cd94dcca0c9458f35abf9" + integrity sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA== + +vscode-languageserver-protocol@3.16.0: + version "3.16.0" + resolved "https://registry.yarnpkg.com/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.16.0.tgz#34135b61a9091db972188a07d337406a3cdbe821" + integrity sha512-sdeUoAawceQdgIfTI+sdcwkiK2KU+2cbEYA0agzM2uqaUy2UpnnGHtWTHVEtS0ES4zHU0eMFRGN+oQgDxlD66A== + dependencies: + vscode-jsonrpc "6.0.0" + vscode-languageserver-types "3.16.0" + +vscode-languageserver-protocol@3.17.5, vscode-languageserver-protocol@^3.17.5: + version "3.17.5" + resolved "https://registry.yarnpkg.com/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.5.tgz#864a8b8f390835572f4e13bd9f8313d0e3ac4bea" + integrity sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg== + dependencies: + vscode-jsonrpc "8.2.0" + vscode-languageserver-types "3.17.5" + +vscode-languageserver-textdocument@^1.0.1, vscode-languageserver-textdocument@^1.0.11, vscode-languageserver-textdocument@^1.0.12: + version "1.0.12" + resolved "https://registry.yarnpkg.com/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.12.tgz#457ee04271ab38998a093c68c2342f53f6e4a631" + integrity sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA== + +vscode-languageserver-types@3.16.0: + version "3.16.0" + resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.16.0.tgz#ecf393fc121ec6974b2da3efb3155644c514e247" + integrity sha512-k8luDIWJWyenLc5ToFQQMaSrqCHiLwyKPHKPQZ5zz21vM+vIVUSvsRpcbiECH4WR88K2XZqc4ScRcZ7nk/jbeA== + +vscode-languageserver-types@3.17.5, vscode-languageserver-types@^3.15.1, vscode-languageserver-types@^3.16.0, vscode-languageserver-types@^3.17.5: + version "3.17.5" + resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.17.5.tgz#3273676f0cf2eab40b3f44d085acbb7f08a39d8a" + integrity sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg== + +vscode-languageserver@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/vscode-languageserver/-/vscode-languageserver-7.0.0.tgz#49b068c87cfcca93a356969d20f5d9bdd501c6b0" + integrity sha512-60HTx5ID+fLRcgdHfmz0LDZAXYEV68fzwG0JWwEPBode9NuMYTIxuYXPg4ngO8i8+Ou0lM7y6GzaYWbiDL0drw== + dependencies: + vscode-languageserver-protocol "3.16.0" + +vscode-languageserver@^9.0.1: + version "9.0.1" + resolved "https://registry.yarnpkg.com/vscode-languageserver/-/vscode-languageserver-9.0.1.tgz#500aef82097eb94df90d008678b0b6b5f474015b" + integrity sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g== + dependencies: + vscode-languageserver-protocol "3.17.5" + +vscode-nls@^5.0.0, vscode-nls@^5.2.0: + version "5.2.0" + resolved "https://registry.yarnpkg.com/vscode-nls/-/vscode-nls-5.2.0.tgz#3cb6893dd9bd695244d8a024bdf746eea665cc3f" + integrity sha512-RAaHx7B14ZU04EU31pT+rKz2/zSl7xMsfIZuo8pd+KZO6PXtQmpevpq3vxvWNcrGbdmhM/rr5Uw5Mz+NBfhVng== + +vscode-uri@^2.1.2: + version "2.1.2" + resolved "https://registry.yarnpkg.com/vscode-uri/-/vscode-uri-2.1.2.tgz#c8d40de93eb57af31f3c715dd650e2ca2c096f1c" + integrity sha512-8TEXQxlldWAuIODdukIb+TR5s+9Ds40eSJrw+1iDDA9IFORPjMELarNQE3myz5XIkWWpdprmJjm1/SxMlWOC8A== + +vscode-uri@^3.0.2, vscode-uri@^3.0.8: + version "3.0.8" + resolved "https://registry.yarnpkg.com/vscode-uri/-/vscode-uri-3.0.8.tgz#1770938d3e72588659a172d0fd4642780083ff9f" + integrity sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw== + +web-namespaces@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/web-namespaces/-/web-namespaces-2.0.1.tgz#1010ff7c650eccb2592cebeeaf9a1b253fd40692" + integrity sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ== + +which-pm-runs@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/which-pm-runs/-/which-pm-runs-1.1.0.tgz#35ccf7b1a0fce87bd8b92a478c9d045785d3bf35" + integrity sha512-n1brCuqClxfFfq/Rb0ICg9giSZqCS+pLtccdag6C2HyufBrh3fBOiy9nb6ggRMvWOVH5GrdJskj5iGTZNxd7SA== + +which-pm@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/which-pm/-/which-pm-3.0.0.tgz#78f2088b345a63cec9f838b390332fb1e680221f" + integrity sha512-ysVYmw6+ZBhx3+ZkcPwRuJi38ZOTLJJ33PSHaitLxSKUMsh0LkKd0nC69zZCwt5D+AYUcMK2hhw4yWny20vSGg== + dependencies: + load-yaml-file "^0.2.0" + +widest-line@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/widest-line/-/widest-line-4.0.1.tgz#a0fc673aaba1ea6f0a0d35b3c2795c9a9cc2ebf2" + integrity sha512-o0cyEG0e8GPzT4iGHphIOh0cJOV8fivsXxddQasHPHfoZf1ZexrfeA21w2NaEN1RHE+fXlfISmOE8R9N3u3Qig== + dependencies: + string-width "^5.0.1" + +wrap-ansi@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +wrap-ansi@^8.1.0: + version "8.1.0" + resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz#56dc22368ee570face1b49819975d9b9a5ead214" + integrity sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ== + dependencies: + ansi-styles "^6.1.0" + string-width "^5.0.1" + strip-ansi "^7.0.1" + +wrappy@1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" + integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== + +xdg-basedir@^5.1.0: + version "5.1.0" + resolved "https://registry.yarnpkg.com/xdg-basedir/-/xdg-basedir-5.1.0.tgz#1efba19425e73be1bc6f2a6ceb52a3d2c884c0c9" + integrity sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ== + +xxhash-wasm@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/xxhash-wasm/-/xxhash-wasm-1.0.2.tgz#ecc0f813219b727af4d5f3958ca6becee2f2f1ff" + integrity sha512-ibF0Or+FivM9lNrg+HGJfVX8WJqgo+kCLDc4vx6xMeTce7Aj+DLttKbxxRR/gNLSAelRc1omAPlJ77N/Jem07A== + +y18n@^5.0.5: + version "5.0.8" + resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55" + integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== + +yallist@^3.0.2: + version "3.1.1" + resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd" + integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g== + +yaml-language-server@~1.15.0: + version "1.15.0" + resolved "https://registry.yarnpkg.com/yaml-language-server/-/yaml-language-server-1.15.0.tgz#3bd36f1f7fd74e63b591e5148df992c7327be05a" + integrity sha512-N47AqBDCMQmh6mBLmI6oqxryHRzi33aPFPsJhYy3VTUGCdLHYjGh4FZzpUjRlphaADBBkDmnkM/++KNIOHi5Rw== + dependencies: + ajv "^8.11.0" + lodash "4.17.21" + request-light "^0.5.7" + vscode-json-languageservice "4.1.8" + vscode-languageserver "^7.0.0" + vscode-languageserver-textdocument "^1.0.1" + vscode-languageserver-types "^3.16.0" + vscode-nls "^5.0.0" + vscode-uri "^3.0.2" + yaml "2.2.2" + optionalDependencies: + prettier "2.8.7" + +yaml@2.2.2: + version "2.2.2" + resolved "https://registry.yarnpkg.com/yaml/-/yaml-2.2.2.tgz#ec551ef37326e6d42872dad1970300f8eb83a073" + integrity sha512-CBKFWExMn46Foo4cldiChEzn7S7SRV+wqiluAb6xmueD/fGyRHIhX8m14vVGgeFWjN540nKCNVj6P21eQjgTuA== + +yaml@^2.5.0, yaml@^2.5.1: + version "2.5.1" + resolved "https://registry.yarnpkg.com/yaml/-/yaml-2.5.1.tgz#c9772aacf62cb7494a95b0c4f1fb065b563db130" + integrity sha512-bLQOjaX/ADgQ20isPJRvF0iRUHIxVhYvr53Of7wGcWlO2jvtUlH5m87DsmulFVxRpNLOnI4tB6p/oh8D7kpn9Q== + +yargs-parser@^21.1.1: + version "21.1.1" + resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35" + integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw== + +yargs@^17.7.2: + version "17.7.2" + resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.7.2.tgz#991df39aca675a192b816e1e0363f9d75d2aa269" + integrity sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w== + dependencies: + cliui "^8.0.1" + escalade "^3.1.1" + get-caller-file "^2.0.5" + require-directory "^2.1.1" + string-width "^4.2.3" + y18n "^5.0.5" + yargs-parser "^21.1.1" + +yocto-queue@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-1.1.1.tgz#fef65ce3ac9f8a32ceac5a634f74e17e5b232110" + integrity sha512-b4JR1PFR10y1mKjhHY9LaGo6tmrgjit7hxVIeAmyMw3jegXR4dhYqLaQF5zMXZxY7tLpMyJeLjr1C4rLmkVe8g== + +zod-to-json-schema@^3.23.2: + version "3.23.3" + resolved "https://registry.yarnpkg.com/zod-to-json-schema/-/zod-to-json-schema-3.23.3.tgz#56cf4e0bd5c4096ab46e63159e20998ec7b19c39" + integrity sha512-TYWChTxKQbRJp5ST22o/Irt9KC5nj7CdBKYB/AosCRdj/wxEMvv4NNaj9XVUHDOIp53ZxArGhnw5HMZziPFjog== + +zod-to-ts@^1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/zod-to-ts/-/zod-to-ts-1.2.0.tgz#873a2fd8242d7b649237be97e0c64d7954ae0c51" + integrity sha512-x30XE43V+InwGpvTySRNz9kB7qFU8DlyEy7BsSTCHPH1R0QasMmHWZDCzYm6bVXtj/9NNJAZF3jW8rzFvH5OFA== + +zod@^3.23.8: + version "3.23.8" + resolved "https://registry.yarnpkg.com/zod/-/zod-3.23.8.tgz#e37b957b5d52079769fb8097099b592f0ef4067d" + integrity sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g== + +zwitch@^2.0.0, zwitch@^2.0.4: + version "2.0.4" + resolved "https://registry.yarnpkg.com/zwitch/-/zwitch-2.0.4.tgz#c827d4b0acb76fc3e685a4c6ec2902d51070e9d7" + integrity sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A== diff --git a/package.json b/package.json index abe070f48..7de2208f2 100644 --- a/package.json +++ b/package.json @@ -37,7 +37,8 @@ "src/**/*", "bin/**/*", "stdlib/**/*", - "!**/test" + "!**/test", + "!/docs" ], "main": "./dist/main.js", "bin": {