Full Code of lutzroeder/netron for AI

main 169fd200a460 cached

252 files

26.5 MB

4.2M tokens

6485 symbols

1 requests

Copy disabled (too large) Download .txt

Showing preview only (16,860K chars total). Download the full file to get everything.

Repository: lutzroeder/netron
Branch: main
Commit: 169fd200a460
Files: 252
Total size: 26.5 MB

Directory structure:
gitextract__jg6eqyf/

├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   └── feature_request.md
│   └── workflows/
│       ├── build.yml
│       └── publish.yml
├── .gitignore
├── .npmrc
├── .vscode/
│   ├── launch.json
│   └── settings.json
├── CITATION.cff
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── eslint.config.js
├── package.js
├── package.json
├── package.py
├── publish/
│   ├── electron-builder.json
│   ├── icon.html
│   └── icon.icns
├── pyproject.toml
├── source/
│   ├── __init__.py
│   ├── acuity-metadata.json
│   ├── acuity.js
│   ├── app.js
│   ├── armnn-metadata.json
│   ├── armnn-schema.js
│   ├── armnn.js
│   ├── barracuda.js
│   ├── base.js
│   ├── bigdl-metadata.json
│   ├── bigdl-proto.js
│   ├── bigdl.js
│   ├── browser.js
│   ├── caffe-metadata.json
│   ├── caffe-proto.js
│   ├── caffe.js
│   ├── caffe2-metadata.json
│   ├── caffe2-proto.js
│   ├── caffe2.js
│   ├── catboost-schema.js
│   ├── catboost.js
│   ├── circle-metadata.json
│   ├── circle-schema.js
│   ├── circle.js
│   ├── cntk-metadata.json
│   ├── cntk-proto.js
│   ├── cntk.js
│   ├── coreml-metadata.json
│   ├── coreml-proto.js
│   ├── coreml.js
│   ├── dagre.js
│   ├── darknet-metadata.json
│   ├── darknet.js
│   ├── desktop.mjs
│   ├── dl4j-metadata.json
│   ├── dl4j.js
│   ├── dlc-metadata.json
│   ├── dlc-schema.js
│   ├── dlc.js
│   ├── dnn-metadata.json
│   ├── dnn-proto.js
│   ├── dnn.js
│   ├── dot.js
│   ├── espdl-metadata.json
│   ├── espdl-schema.js
│   ├── espdl.js
│   ├── espresso-metadata.json
│   ├── espresso.js
│   ├── executorch-schema.js
│   ├── executorch.js
│   ├── flatbuffers.js
│   ├── flax.js
│   ├── flexbuffers.js
│   ├── flux-metadata.json
│   ├── flux.js
│   ├── gguf-metadata.json
│   ├── gguf.js
│   ├── grapher.css
│   ├── grapher.js
│   ├── hailo-metadata.json
│   ├── hailo.js
│   ├── hdf5.js
│   ├── hickle.js
│   ├── imgdnn.js
│   ├── index.html
│   ├── index.js
│   ├── json.js
│   ├── kann-metadata.json
│   ├── kann-schema.js
│   ├── kann.js
│   ├── keras-metadata.json
│   ├── keras-proto.js
│   ├── keras.js
│   ├── kmodel.js
│   ├── lasagne-metadata.json
│   ├── lasagne.js
│   ├── lightgbm.js
│   ├── mediapipe.js
│   ├── megengine-metadata.json
│   ├── megengine-schema.js
│   ├── megengine.js
│   ├── message.js
│   ├── mlir-metadata.json
│   ├── mlir.js
│   ├── mlnet-metadata.json
│   ├── mlnet.js
│   ├── mnn-metadata.json
│   ├── mnn-schema.js
│   ├── mnn.js
│   ├── mslite-metadata.json
│   ├── mslite-schema.js
│   ├── mslite.js
│   ├── mxnet-metadata.json
│   ├── mxnet.js
│   ├── ncnn-metadata.json
│   ├── ncnn.js
│   ├── nnabla-metadata.json
│   ├── nnabla-proto.js
│   ├── nnabla.js
│   ├── nnc.js
│   ├── nnef.js
│   ├── node.js
│   ├── numpy.js
│   ├── om-metadata.json
│   ├── om-proto.js
│   ├── om.js
│   ├── onednn-metadata.json
│   ├── onednn.js
│   ├── onnx-metadata.json
│   ├── onnx-proto.js
│   ├── onnx-schema.js
│   ├── onnx.js
│   ├── onnx.py
│   ├── openvino-metadata.json
│   ├── openvino.js
│   ├── paddle-metadata.json
│   ├── paddle-proto.js
│   ├── paddle-schema.js
│   ├── paddle.js
│   ├── pickle.js
│   ├── protobuf.js
│   ├── python.js
│   ├── pytorch-metadata.json
│   ├── pytorch-proto.js
│   ├── pytorch-schema.js
│   ├── pytorch.js
│   ├── pytorch.py
│   ├── qnn-metadata.json
│   ├── qnn.js
│   ├── rknn-metadata.json
│   ├── rknn-schema.js
│   ├── rknn.js
│   ├── safetensors.js
│   ├── sentencepiece-proto.js
│   ├── sentencepiece.js
│   ├── server.py
│   ├── sklearn-metadata.json
│   ├── sklearn.js
│   ├── tar.js
│   ├── tengine-metadata.json
│   ├── tengine.js
│   ├── tensorrt.js
│   ├── text.js
│   ├── tf-metadata.json
│   ├── tf-proto.js
│   ├── tf.js
│   ├── tflite-metadata.json
│   ├── tflite-schema.js
│   ├── tflite.js
│   ├── tnn-metadata.json
│   ├── tnn.js
│   ├── torch-metadata.json
│   ├── torch.js
│   ├── tosa-metadata.json
│   ├── tosa-schema.js
│   ├── tosa.js
│   ├── transformers.js
│   ├── tvm.js
│   ├── uff-metadata.json
│   ├── uff-proto.js
│   ├── uff.js
│   ├── view.js
│   ├── weka.js
│   ├── worker.js
│   ├── xgboost.js
│   ├── xml.js
│   ├── xmodel-proto.js
│   ├── xmodel.js
│   └── zip.js
├── test/
│   ├── backend.py
│   ├── browser.spec.js
│   ├── desktop.spec.js
│   ├── measures.py
│   ├── mock.js
│   ├── models.js
│   ├── models.json
│   ├── playwright.config.js
│   ├── playwright.reporter.js
│   └── worker.js
└── tools/
    ├── armnn
    ├── bigdl
    ├── caffe
    ├── caffe-script.js
    ├── catboost
    ├── circle
    ├── circle-script.js
    ├── cntk
    ├── coreml
    ├── dlc
    ├── dlc.fbs
    ├── dnn
    ├── dnn.proto
    ├── espdl
    ├── espdl-script.js
    ├── executorch
    ├── flatc.js
    ├── gguf
    ├── kann
    ├── keras
    ├── keras_script.py
    ├── mediapipe
    ├── megengine
    ├── megengine-script.js
    ├── mlir
    ├── mlir-script.js
    ├── mnn
    ├── mslite
    ├── mslite-script.js
    ├── nnabla
    ├── nnabla_script.py
    ├── om
    ├── om.proto
    ├── onnx
    ├── onnx_script.py
    ├── paddle
    ├── protoc.js
    ├── pytorch
    ├── pytorch_script.py
    ├── rknn
    ├── rknn.fbs
    ├── sentencepiece
    ├── sklearn
    ├── sklearn_script.py
    ├── tablegen.js
    ├── tf
    ├── tf_script.py
    ├── tflite-script.js
    ├── tosa
    ├── tosa-script.js
    ├── uff
    ├── uff.proto
    └── xmodel

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Create a report to help us improve
labels: bug
---

- Netron app and version: <!-- For example: 3.8.2 Desktop app, 2.9.0 Website or 3.9.2 Python Server -->
- OS and browser version: <!-- For example macOS 10.15.6 (19G73) + Chrome 84.0.4147.89 -->

Steps to Reproduce:

1.
2.

Please attach or link model files to reproduce the issue.


================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature request
about: Suggest an idea for this project
labels: feature
---
<!-- Please search existing issues to avoid creating duplicates. -->
<!-- Describe the feature you'd like. -->


================================================
FILE: .github/workflows/build.yml
================================================

name: Build

on:
  push:
    branches: [ '**' ]
    tags-ignore: [ '**' ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    name: Build
    runs-on: ${{ matrix.os }}

    strategy:
      matrix:
        os: [ macos-latest, ubuntu-latest, windows-latest ]

    steps:
      - name: Clone Git repository
        uses: actions/checkout@v4

      - name: Install Node.js
        uses: actions/setup-node@v4
        with:
          node-version: latest

      - name: Install Python
        uses: actions/setup-python@v5
        with:
          python-version: 3.x

      - name: Install Packages
        run: npm run install

      - name: Validate
        run: npm run validate

      - name: Build Python Server
        run: npm run build python

      - name: Build Electron
        shell: bash
        run: |
          npx electron-builder install-app-deps
          case "${{ matrix.os }}" in
            macos*)
              npm run build electron mac
              ;;
            ubuntu*)
              sudo apt-get install rpm --yes
              npm run build electron linux
              ;;
            windows*)
              npm run build electron windows
              ;;
          esac

  analyze:
    name: Analyze
    runs-on: ubuntu-latest

    permissions:
      security-events: write

    strategy:
      fail-fast: false
      matrix:
        language: [ 'javascript', 'python' ]

    steps:
      - name: Clone Git repository
        uses: actions/checkout@v4

      - name: Initialize CodeQL
        uses: github/codeql-action/init@v3
        with:
          languages: ${{ matrix.language }}

      - name: Autobuild
        uses: github/codeql-action/autobuild@v3

      - name: Perform CodeQL Analysis
        uses: github/codeql-action/analyze@v3


================================================
FILE: .github/workflows/publish.yml
================================================

name: Publish

on:
  push:
    tags: [ 'v**' ]

jobs:
  publish:
    runs-on: ${{ matrix.os }}

    strategy:
      matrix:
        os: [ macos-latest, ubuntu-latest, windows-latest ]

    steps:
      - name: Check out Git repository
        uses: actions/checkout@v4

      - name: Git credentials
        run: |
          git config --global user.name ${{ secrets.PUBLISH_GITHUB_USER_NAME }}
          git config --global user.email ${{ secrets.PUBLISH_GITHUB_USER_EMAIL }}

      - name: Install Node.js
        uses: actions/setup-node@v4
        with:
          node-version: latest

      - name: Install Python
        uses: actions/setup-python@v5
        with:
          python-version: 3.x

      - name: Install Packages
        run: npm run install

      - name: Publish Electron
        shell: bash
        env:
          GITHUB_TOKEN: ${{ secrets.PUBLISH_GITHUB_TOKEN }}
          APPLE_API_KEY: ~/.private_keys/AuthKey_${{ secrets.APPLE_API_KEY_ID }}.p8
          APPLE_API_KEY_ID: ${{ secrets.APPLE_API_KEY_ID }}
          APPLE_API_ISSUER: ${{ secrets.APPLE_API_ISSUER }}
          CSC_LINK: ${{ secrets.CSC_LINK }}
          CSC_KEY_PASSWORD: ${{ secrets.CSC_KEY_PASSWORD }}
          AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
          AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
          AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
        run: |
          npx electron-builder install-app-deps
          case "${{ matrix.os }}" in
            macos*)
              mkdir -p ~/.private_keys
              echo '${{ secrets.APPLE_API_KEY }}' > ~/.private_keys/AuthKey_${{ secrets.APPLE_API_KEY_ID }}.p8
              npm run publish electron mac
              ;;
            ubuntu*)
              sudo apt-get install rpm --yes
              npm run publish electron linux
              ;;
            windows*)
              unset CSC_LINK;
              unset CSC_KEY_PASSWORD;
              npm run publish electron windows
              ;;
          esac

      - if: startsWith(matrix.os, 'ubuntu')
        name: Publish Python
        env:
          TWINE_USERNAME: __token__
          TWINE_PASSWORD: ${{ secrets.TWINE_PASSWORD }}
        run: npm run publish python

      - if: startsWith(matrix.os, 'ubuntu')
        name: Publish Web
        env:
          GITHUB_TOKEN: ${{ secrets.PUBLISH_GITHUB_TOKEN }}
          GITHUB_USER: ${{ secrets.PUBLISH_GITHUB_USER }}
        run: git push origin HEAD:release --force

      - if: false # startsWith(matrix.os, 'macos')
        name: Publish cask
        env:
          GITHUB_TOKEN: ${{ secrets.PUBLISH_GITHUB_TOKEN }}
          GITHUB_USER: ${{ secrets.PUBLISH_GITHUB_USER }}
        run: npm run publish cask

      - if: startsWith(matrix.os, 'windows')
        name: Publish winget
        env:
          GITHUB_USER: ${{ secrets.PUBLISH_GITHUB_USER }}
          GITHUB_TOKEN: ${{ secrets.PUBLISH_GITHUB_TOKEN }}
          WINGET_TOKEN: ${{ secrets.WINGET_TOKEN }}
        run: npm run publish winget


================================================
FILE: .gitignore
================================================
.DS_Store
.DS_Store?
.claude
.eslintcache
.ruff_cache
.specify
.yarn
dist/*
node_modules/*
test-results/*
third_party/*
yarn.lock
*.pyc


================================================
FILE: .npmrc
================================================
loglevel=silent

================================================
FILE: .vscode/launch.json
================================================
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Desktop View",
            "type": "chrome",
            "request": "launch",
            "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/electron",
            "windows": {
                "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/electron.cmd"
            },
            "osx": {
                "runtimeExecutable": "${workspaceFolder}/node_modules/electron/dist/Electron.app/Contents/MacOS/Electron"
            },
            "runtimeArgs": [
                "${workspaceRoot}",
                "--enable-logging",
                "--remote-debugging-port=9222"
            ],
            "webRoot": "${workspaceRoot}"
        },
        {
            "name": "Desktop App",
            "type": "node",
            "request": "launch",
            "program": "${workspaceFolder}/source/app.js",
            "runtimeExecutable": "electron",
            "osx": {
                "runtimeExecutable": "${workspaceFolder}/node_modules/electron/dist/Electron.app/Contents/MacOS/Electron"
            }
        },
        {
            "name": "Browser",
            "type": "debugpy",
            "request": "launch",
            "program": "${workspaceFolder}/package.py",
            "args": [ "build", "start" ],
            "justMyCode": true,
            "pathMappings": [
                {
                    "localRoot": "${workspaceFolder}/source",
                    "remoteRoot": "${workspaceFolder}/dist/pypi/netron",
                }
            ],
            "serverReadyAction": {
                "action": "debugWithChrome",
                "pattern": "Serving .*at http://localhost:([0-9]+)",
                "uriFormat": "http://localhost:%s",
                "webRoot": "${workspaceFolder}/source",
            },
        },
        {
            "name": "Test Models",
            "type": "node",
            "request": "launch",
            "program": "${workspaceFolder}/test/models.js",
            "args": [ "tag:validation" ],
            "console": "integratedTerminal",
        },
        {
            "name": "Test Desktop",
            "type": "node",
            "request": "launch",
            "runtimeExecutable": "npm",
            "runtimeArgs": ["run", "test", "desktop"],
            "console": "integratedTerminal",
        },
        {
            "name": "Test Browser",
            "type": "node",
            "request": "launch",
            "runtimeExecutable": "npm",
            "runtimeArgs": ["run", "test", "browser"],
            "console": "integratedTerminal",
        },
        {
            "name": "Test Backend",
            "type": "debugpy",
            "request": "launch",
            "program": "${workspaceFolder}/test/backend.py",
            "args": [],
            "console": "integratedTerminal",
            "justMyCode": true,
            "serverReadyAction": {
                "action": "debugWithChrome",
                "pattern": "Serving .*at http://localhost:([0-9]+)",
                "uriFormat": "http://localhost:%s",
                "webRoot": "${workspaceFolder}/source",
            },
        },
        {
            "name": "Tools Python",
            "type": "debugpy",
            "request": "launch",
            "program": "${file}",
            "args": [],
            "console": "integratedTerminal",
            "justMyCode": true
        },
        {
            "name": "Tools JavaScript",
            "type": "node",
            "request": "launch",
            "program": "${file}",
            "args": [],
            "console": "integratedTerminal",
        }
    ]
}

================================================
FILE: .vscode/settings.json
================================================
{
    "eslint.lintTask.enable": true,
    "files.exclude": {
        "dist": true,
        "node_modules": true,
        "third_party": true
    },
    "search.exclude": {
        "dist": true,
        "node_modules": true,
        "third_party": true
    }
}

================================================
FILE: CITATION.cff
================================================
cff-version: 1.2.0
title: "Netron, Visualizer for neural network, deep learning, and machine learning models"
authors:
- family-names: "Roeder"
  given-names: "Lutz"
  orcid: "https://orcid.org/0000-0003-4994-7839"
doi: "10.5281/zenodo.5854962"
date-released: 2017-12-04
license: "MIT"
url: "https://github.com/lutzroeder/netron"
repository-code: "https://github.com/lutzroeder/netron"
message: "If you use Netron in your research, please cite it using these metadata."


================================================
FILE: CONTRIBUTING.md
================================================
# How to Develop Netron

## Debugging

Netron can run as both an [Electron](https://electronjs.org) app or a web app.

To start the Electron app, install [Node.js](https://nodejs.org) and run: 

```bash
git clone https://github.com/lutzroeder/netron
cd netron
npm install
npm start
```

To debug the Electron app, open the folder in [Visual Studio Code](https://code.visualstudio.com) and press <kbd>F5</kbd>. To attach the debugger to the render process select the `Debug` tab and pick `Desktop View` before launching.

To build and launch the web app, pick `Browser` in the `Debug` tab or run this command:

```bash
python package.py build start --browse
```

## Validation

To validate changes run:

```bash
npm run lint
npm test [format] # e.g. npm test onnx
```


================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) Lutz Roeder

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

================================================
FILE: README.md
================================================
<div align="center">
<img width="400px" height="100px" src="https://github.com/lutzroeder/netron/raw/main/.github/logo-light.svg#gh-light-mode-only">
<img width="400px" height="100px" src="https://github.com/lutzroeder/netron/raw/main/.github/logo-dark.svg#gh-dark-mode-only">
</div>

Netron is a viewer for neural network, deep learning and machine learning models.

Netron supports ONNX, TensorFlow Lite, PyTorch, torch.export, ExecuTorch, Core ML, Keras, Caffe, Darknet, TensorFlow.js, Safetensors and NumPy.

Netron has experimental support for TorchScript, MLIR, TensorFlow, OpenVINO, RKNN, ncnn, MNN, PaddlePaddle, GGUF and scikit-learn.

<p align='center'><a href='https://www.lutzroeder.com/ai'><img src='.github/screenshot.png' width='800'></a></p>

## Install

**Browser**: [**Start**](https://netron.app) the browser version.

**macOS**: [**Download**](https://github.com/lutzroeder/netron/releases/latest) the `.dmg` file or run `brew install --cask netron`.

**Linux**: [**Download**](https://github.com/lutzroeder/netron/releases/latest) the `.deb` or `.rpm` file.

**Windows**: [**Download**](https://github.com/lutzroeder/netron/releases/latest) the `.exe` installer or run `winget install -s winget netron`.

**Python**: `pip install netron`, then run `netron [FILE]` or `netron.start('[FILE]')`.

## Models

Sample model files to download or open using the browser version:

 * **ONNX**: [squeezenet](https://github.com/onnx/models/raw/main/validated/vision/classification/squeezenet/model/squeezenet1.0-3.onnx) [[open](https://netron.app?url=https://github.com/onnx/models/raw/main/validated/vision/classification/squeezenet/model/squeezenet1.0-3.onnx)]
 * **TorchScript**: [traced_online_pred_layer](https://github.com/ApolloAuto/apollo/raw/master/modules/prediction/data/traced_online_pred_layer.pt) [[open](https://netron.app?url=https://github.com/ApolloAuto/apollo/raw/master/modules/prediction/data/traced_online_pred_layer.pt)]
 * **TensorFlow Lite**: [yamnet](https://huggingface.co/thelou1s/yamnet/resolve/main/lite-model_yamnet_tflite_1.tflite) [[open](https://netron.app?url=https://huggingface.co/thelou1s/yamnet/blob/main/lite-model_yamnet_tflite_1.tflite)]
 * **TensorFlow**: [chessbot](https://github.com/srom/chessbot/raw/master/model/chessbot.pb) [[open](https://netron.app?url=https://github.com/srom/chessbot/raw/master/model/chessbot.pb)]
 * **Keras**: [mobilenet](https://github.com/aio-libs/aiohttp-demos/raw/master/demos/imagetagger/tests/data/mobilenet.h5) [[open](https://netron.app?url=https://github.com/aio-libs/aiohttp-demos/raw/master/demos/imagetagger/tests/data/mobilenet.h5)]

* **MLIR**: [edge_detection](https://github.com/iree-org/iree/raw/main/tests/e2e/stablehlo_models/edge_detection.mlir) [[open](https://netron.app?url=https://github.com/iree-org/iree/blob/main/tests/e2e/stablehlo_models/edge_detection.mlir)]

 * **Core ML**: [exermote](https://github.com/Lausbert/Exermote/raw/master/ExermoteInference/ExermoteCoreML/ExermoteCoreML/Model/Exermote.mlmodel) [[open](https://netron.app?url=https://github.com/Lausbert/Exermote/raw/master/ExermoteInference/ExermoteCoreML/ExermoteCoreML/Model/Exermote.mlmodel)]
 * **Darknet**: [yolo](https://github.com/AlexeyAB/darknet/raw/master/cfg/yolo.cfg) [[open](https://netron.app?url=https://github.com/AlexeyAB/darknet/raw/master/cfg/yolo.cfg)]


================================================
FILE: eslint.config.js
================================================

export default [
    {
        ignores: [
            'dist/**',
            'third_party/**',
        ]
    },
    {
        languageOptions: {
            globals: {
                atob: 'readonly',
                BigInt: 'readonly',
                console: 'readonly',
                global: 'readonly',
                process: 'readonly',
                self: 'readonly',
                TextDecoder: 'readonly',
                TextEncoder: 'readonly',
                window: 'readonly',
            },
            sourceType: 'module'
        },
        rules: {
            'accessor-pairs': 'error',
            'array-bracket-spacing': 'error',
            'array-callback-return': 'error',
            // 'arrow-body-style': 'error',
            'arrow-parens': 'error',
            'block-scoped-var': 'error',
            'brace-style': 'error',
            // 'camelcase': 'error',
            // 'capitalized-comments': 'error',
            // 'class-methods-use-this': 'error',
            // 'complexity': 'error',
            'computed-property-spacing': 'error',
            'consistent-return': 'error',
            'consistent-this': 'error',
            'constructor-super': 'error',
            'curly': 'error',
            'default-case': 'error',
            'default-case-last': 'error',
            'default-param-last': 'error',
            'dot-notation': 'error',
            'eqeqeq': 'error',
            'for-direction': 'error',
            'func-name-matching': 'error',
            // 'func-names': 'error',
            'func-style': 'error',
            'getter-return': 'error',
            'grouped-accessor-pairs': 'error',
            'guard-for-in': 'error',
            'id-denylist': 'error',
            // 'id-length': 'error',
            'id-match': 'error',
            'indent': ['error', 4, { 'SwitchCase': 1 }],
            'init-declarations': 'error',
            'keyword-spacing': 'error',
            // 'line-comment-position': 'error',
            // 'logical-assignment-operators': 'error',
            // 'max-classes-per-file': 'error',
            // 'max-depth': 'error',
            // 'max-lines': 'error',
            // 'max-lines-per-function': 'error',
            'max-nested-callbacks': 'error',
            // 'max-params': 'error',
            // 'max-statements': 'error',
            // 'multiline-comment-style': 'error',
            // 'new-cap': 'error',
            'no-alert': 'error',
            'no-array-constructor': 'error',
            'no-async-promise-executor': 'error',
            'no-await-in-loop': 'error',
            // 'no-bitwise': 'error',
            'no-caller': 'error',
            'no-case-declarations': 'error',
            'no-class-assign': 'error',
            'no-compare-neg-zero': 'error',
            'no-cond-assign': 'error',
            'no-console': 'error',
            'no-const-assign': 'error',
            'no-constant-binary-expression': 'error',
            'no-constant-condition': 'error',
            'no-constructor-return': 'error',
            // 'no-continue': 'error',
            'no-control-regex': 'error',
            'no-debugger': 'error',
            'no-delete-var': 'error',
            'no-div-regex': 'error',
            'no-dupe-args': 'error',
            'no-dupe-class-members': 'error',
            'no-dupe-else-if': 'error',
            'no-dupe-keys': 'error',
            'no-duplicate-case': 'error',
            'no-duplicate-imports': 'error',
            'no-else-return': 'error',
            'no-empty': 'error',
            'no-empty-character-class': 'error',
            // 'no-empty-function': 'error',
            'no-empty-pattern': 'error',
            'no-empty-static-block': 'error',
            'no-eq-null': 'error',
            'no-eval': 'error',
            'no-ex-assign': 'error',
            'no-extend-native': 'error',
            'no-extra-bind': 'error',
            'no-extra-boolean-cast': 'error',
            'no-extra-label': 'error',
            'no-extra-semi': 'error',
            'no-fallthrough': 'error',
            'no-func-assign': 'error',
            'no-global-assign': 'error',
            'no-implicit-coercion': 'error',
            'no-implicit-globals': 'error',
            'no-implied-eval': 'error',
            'no-import-assign': 'error',
            // 'no-inline-comments': 'error',
            'no-inner-declarations': 'error',
            'no-invalid-regexp': 'error',
            'no-invalid-this': 'error',
            'no-irregular-whitespace': 'error',
            'no-iterator': 'error',
            'no-label-var': 'error',
            'no-labels': 'error',
            'no-lone-blocks': 'error',
            'no-lonely-if': 'error',
            'no-loop-func': 'error',
            'no-loss-of-precision': 'error',
            // 'no-magic-numbers': 'error',
            'no-misleading-character-class': 'error',
            'no-multi-assign': 'error',
            'no-multi-str': 'error',
            'no-multiple-empty-lines': ['error', { 'max': 1 }],
            'no-negated-condition': 'error',
            'no-nested-ternary': 'error',
            'no-new': 'error',
            'no-new-func': 'error',
            'no-new-native-nonconstructor': 'error',
            'no-new-wrappers': 'error',
            'no-nonoctal-decimal-escape': 'error',
            'no-obj-calls': 'error',
            'no-object-constructor': 'error',
            'no-octal': 'error',
            'no-octal-escape': 'error',
            // 'no-param-reassign': 'error',
            // 'no-plusplus': 'error',
            'no-promise-executor-return': 'error',
            'no-proto': 'error',
            'no-prototype-builtins': 'error',
            'no-redeclare': 'error',
            'no-regex-spaces': 'error',
            'no-restricted-exports': 'error',
            'no-restricted-globals': 'error',
            'no-restricted-imports': 'error',
            'no-restricted-properties': 'error',
            'no-restricted-syntax': 'error',
            'no-return-assign': 'error',
            'no-script-url': 'error',
            'no-self-assign': 'error',
            'no-self-compare': 'error',
            'no-sequences': 'error',
            'no-setter-return': 'error',
            // 'no-shadow': 'error',
            'no-shadow-restricted-names': 'error',
            'no-sparse-arrays': 'error',
            'no-template-curly-in-string': 'error',
            // 'no-ternary': 'error',
            'no-this-before-super': 'error',
            'no-throw-literal': 'error',
            'no-trailing-spaces': 'error',
            'no-undef': 'error',
            'no-undef-init': 'error',
            // 'no-undefined': 'error',
            // 'no-underscore-dangle': 'error',
            'no-unexpected-multiline': 'error',
            'no-unmodified-loop-condition': 'error',
            // 'no-unneeded-ternary': 'error',
            'no-unreachable': 'error',
            'no-unreachable-loop': 'error',
            'no-unsafe-finally': 'error',
            'no-unsafe-negation': 'error',
            'no-unsafe-optional-chaining': 'error',
            'no-unused-expressions': 'error',
            'no-unused-labels': 'error',
            'no-unused-private-class-members': 'error',
            'no-unused-vars': 'error',
            'no-use-before-define': 'error',
            // 'no-useless-assignment': 'error',
            'no-useless-backreference': 'error',
            'no-useless-call': 'error',
            'no-useless-catch': 'error',
            'no-useless-computed-key': 'error',
            'no-useless-concat': 'error',
            'no-useless-constructor': 'error',
            'no-useless-escape': 'error',
            'no-useless-rename': 'error',
            'no-useless-return': 'error',
            'no-var': 'error',
            'no-void': 'error',
            'no-warning-comments': 'error',
            'no-with': 'error',
            'object-curly-spacing': ['error', 'always'],
            'object-shorthand': 'error',
            // 'one-var': 'error',
            'operator-assignment': 'error',
            'prefer-arrow-callback': 'error',
            'prefer-const': 'error',
            'prefer-destructuring': ['error', { 'array': false }],
            // 'prefer-exponentiation-operator': 'error',
            // 'prefer-named-capture-group': 'error',
            'prefer-numeric-literals': 'error',
            // 'prefer-object-has-own': 'error',
            'prefer-object-spread': 'error',
            'prefer-promise-reject-errors': 'error',
            'prefer-regex-literals': 'error',
            'prefer-rest-params': 'error',
            'prefer-spread': 'error',
            'prefer-template': 'error',
            'radix': 'error',
            'require-atomic-updates': 'error',
            // 'require-await': 'error',
            // 'require-unicode-regexp': 'error',
            'require-yield': 'error',
            'semi': ['error', 'always'],
            'sort-imports': 'error',
            // 'sort-keys': 'error',
            'sort-vars': 'error',
            'space-before-blocks': 'error',
            'space-in-parens': 'error',
            'space-infix-ops': 'error',
            'strict': 'error',
            'symbol-description': 'error',
            'template-curly-spacing': 'error',
            'unicode-bom': 'error',
            'use-isnan': 'error',
            'valid-typeof': 'error',
            'vars-on-top': 'error',
            'yoda': 'error'
        }
    },
    {
        files: ['source/index.js'],
        languageOptions: {
            sourceType: 'script',
            ecmaVersion: 2015
        },
        rules: {
            'no-var': 'off',
            'prefer-arrow-callback': 'off',
            'prefer-template': 'off',
            'prefer-destructuring': 'off',
            'vars-on-top': 'off',
            'strict': 'off'
        }
    }
];


================================================
FILE: package.js
================================================

import * as child_process from 'child_process';
import * as crypto from 'crypto';
import * as fs from 'fs/promises';
import * as os from 'os';
import * as path from 'path';
import * as url from 'url';

const args = process.argv.slice(2);

const read = (match) => {
    if (args.length > 0 && (!match || args[0] === match)) {
        return args.shift();
    }
    return null;
};

let configuration = null;

const dirname = (...args) => {
    const file = url.fileURLToPath(import.meta.url);
    const dir = path.dirname(file);
    return path.join(dir, ...args);
};

const load = async () => {
    const file = dirname('package.json');
    const content = await fs.readFile(file, 'utf-8');
    configuration = JSON.parse(content);
};

const clearLine = () => {
    if (process.stdout.clearLine) {
        process.stdout.clearLine();
    }
};

const write = (message) => {
    if (process.stdout.write) {
        process.stdout.write(message);
    }
};

const writeLine = (message) => {
    write(message + os.EOL);
};

const access = async (path) => {
    try {
        await fs.access(path);
        return true;
    } catch {
        return false;
    }
};

const rm = async (...args) => {
    const dir = dirname(...args);
    const exists = await access(dir);
    if (exists) {
        const paths = path.join(...args);
        writeLine(`rm ${paths}`);
        const options = { recursive: true, force: true };
        await fs.rm(dir, options);
    }
};

const mkdir = async (...args) => {
    const dir = dirname(...args);
    const exists = await access(dir);
    if (!exists) {
        const paths = path.join(...args);
        writeLine(`mkdir ${paths}`);
        const options = { recursive: true };
        await fs.mkdir(dir, options);
    }
    return dir;
};

const copy = async (source, target, filter) => {
    let files = await fs.readdir(source);
    files = filter ? files.filter((file) => filter(file)) : files;
    const promises = files.map((file) => fs.copyFile(path.join(source, file), path.join(target, file)));
    await Promise.all(promises);
};

const unlink = async (dir, filter) => {
    let files = await fs.readdir(dir);
    files = filter ? files.filter((file) => filter(file)) : files;
    const promises = files.map((file) => fs.unlink(path.join(dir, file)));
    await Promise.all(promises);
};

const exec = async (command, encoding, cwd) => {
    cwd = cwd || dirname();
    if (encoding) {
        return child_process.spawnSync(command, { shell: true, cwd, encoding });
    }
    child_process.execSync(command, { cwd, stdio: [0,1,2] });
    return '';
};

const sleep = (delay) => {
    return new Promise((resolve) => {
        global.setTimeout(resolve, delay);
    });
};

const request = async (url, init, status) => {
    const response = await global.fetch(url, init);
    if (status !== false && !response.ok) {
        throw new Error(`${response.status.toString()} ${response.statusText}`);
    }
    if (response.body) {
        const reader = response.body.getReader();
        let position = 0;
        const stream = new global.ReadableStream({
            start(controller) {
                const read = async () => {
                    try {
                        const result = await reader.read();
                        if (result.done) {
                            clearLine();
                            controller.close();
                        } else {
                            position += result.value.length;
                            write(`  ${position} bytes\r`);
                            controller.enqueue(result.value);
                            read();
                        }
                    } catch (error) {
                        controller.error(error);
                    }
                };
                read();
            }
        });
        return new global.Response(stream, {
            status: response.status,
            statusText: response.statusText,
            headers: response.headers
        });
    }
    return response;
};

const download = async (url) => {
    writeLine(`download ${url}`);
    const response = await request(url);
    return response.arrayBuffer().then((buffer) => new Uint8Array(buffer));
};

const hash = async (url, algorithm) => {
    const data = await download(url);
    const hash = crypto.createHash(algorithm);
    hash.update(data);
    return hash.digest('hex');
};

const fork = async (organization, repository) => {
    const headers = {
        Authorization: `Bearer ${process.env.GITHUB_TOKEN}`
    };
    writeLine(`github delete ${repository}`);
    await request(`https://api.github.com/repos/${process.env.GITHUB_USER}/${repository}`, {
        method: 'DELETE',
        headers
    }, false);
    await sleep(4000);
    writeLine(`github fork ${repository}`);
    await request(`https://api.github.com/repos/${organization}/${repository}/forks`, {
        method: 'POST',
        headers,
        body: ''
    });
    await sleep(4000);
    await rm('dist', repository);
    writeLine(`github clone ${repository}`);
    await exec(`git clone --depth=2 https://x-access-token:${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USER}/${repository}.git dist/${repository}`);
};

const pullrequest = async (organization, repository, token, body) => {
    writeLine(`github push ${repository}`);
    await exec(`git -C dist/${repository} push`);
    writeLine(`github pullrequest ${repository}`);
    const headers = {
        Authorization: `Bearer ${token}`
    };
    await request(`https://api.github.com/repos/${organization}/${repository}/pulls`, {
        method: 'POST',
        headers,
        body: JSON.stringify(body)
    });
};

const clean = async () => {
    await rm('dist');
    await rm('node_modules');
    await rm('package-lock.json');
    await rm('yarn.lock');
    if (read('purge')) {
        await rm('third_party');
    }
};

const install = async () => {
    const node_modules = dirname('node_modules');
    let exists = await access(node_modules);
    if (exists) {
        const dependencies = { ...configuration.dependencies, ...configuration.devDependencies };
        const matches = await Promise.all(Object.entries(dependencies).map(async ([name, version]) => {
            const file = path.join('node_modules', name, 'package.json');
            const exists = await access(file);
            if (exists) {
                const content = await fs.readFile(file, 'utf8');
                const obj = JSON.parse(content);
                return obj.version === version;
            }
            return false;
        }));
        exists = matches.every((match) => match);
        if (!exists) {
            await clean();
        }
    }
    exists = await access(node_modules);
    if (!exists) {
        await exec('npm install');
    }
    try {
        await exec('python --version', 'utf-8');
        await exec('python -m pip install --upgrade --quiet setuptools ruff');
    } catch {
        // continue regardless of error
    }
};

const start = async () => {
    await install();
    await exec('npx electron .');
};

const build = async (target) => {
    switch (target || read()) {
        case 'web': {
            writeLine('build web');
            await rm('dist', 'web');
            await mkdir('dist', 'web');
            writeLine('cp source/dir dist/dir');
            const source_dir = dirname('source');
            const dist_dir = dirname('dist', 'web');
            const extensions = new Set(['html', 'css', 'js', 'json', 'ico', 'png']);
            await copy(source_dir, dist_dir, (file) => extensions.has(file.split('.').pop()));
            await rm('dist', 'web', 'app.js');
            await rm('dist', 'web', 'node.js');
            await rm('dist', 'web', 'desktop.mjs');
            const contentFile = dirname('dist', 'web', 'index.html');
            let content = await fs.readFile(contentFile, 'utf-8');
            content = content.replace(/(<meta\s*name="version"\s*content=")(.*)(">)/m, (match, p1, p2, p3) => {
                return p1 + configuration.version + p3;
            });
            content = content.replace(/(<meta\s*name="date"\s*content=")(.*)(">)/m, (match, p1, p2, p3) => {
                return p1 + configuration.date + p3;
            });
            await fs.writeFile(contentFile, content, 'utf-8');
            break;
        }
        case 'electron': {
            const key = read();
            const target = key ? `electron ${key}` : 'electron';
            writeLine(`build ${target}`);
            await install();
            await exec('npx electron-builder install-app-deps');
            const table = new Map([
                ['mac',     'npx electron-builder --mac --universal --publish never --config.mac.identity=null'],
                ['windows', 'npx electron-builder --win --x64 --arm64 --publish never --config.win.azureSignOptions='],
                ['linux',   'npx electron-builder --linux --publish never']
            ]);
            const targets = table.has(key) ? [table.get(key)] : Array.from(table.values());
            for (const target of targets) {
                /* eslint-disable no-await-in-loop */
                await exec(target);
                /* eslint-enable no-await-in-loop */
            }
            break;
        }
        case 'python': {
            writeLine('build python');
            await exec('python package.py build version');
            await exec('python -m pip install --user build wheel --quiet');
            await exec('python -m build --wheel --outdir dist/pypi dist/pypi');
            if (read('install')) {
                await exec('python -m pip install --force-reinstall dist/pypi/*.whl');
            }
            break;
        }
        default: {
            writeLine('build');
            await rm('dist');
            await install();
            await build('web');
            await build('electron');
            await build('python');
            break;
        }
    }
};

const publish = async (target) => {
    const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
    const GITHUB_USER = process.env.GITHUB_USER;
    switch (target || read()) {
        case 'web': {
            writeLine('publish web');
            await build('web');
            await rm('dist', 'gh-pages');
            const url = `https://x-access-token:${GITHUB_TOKEN}@github.com/${GITHUB_USER}/netron.git`;
            await exec(`git clone --depth=1 ${url} --branch gh-pages ./dist/gh-pages 2>&1 > /dev/null`);
            writeLine('cp dist/web dist/gh-pages');
            const source_dir = dirname('dist', 'web');
            const target_dir = dirname('dist', 'gh-pages');
            await unlink(target_dir, (file) => file !== '.git');
            await copy(source_dir, target_dir);
            await exec('git -C dist/gh-pages add --all');
            await exec('git -C dist/gh-pages commit --amend --no-edit');
            await exec('git -C dist/gh-pages push --force origin gh-pages');
            break;
        }
        case 'electron': {
            const key = read();
            const target = key ? ` ${key}` : '';
            writeLine(`publish electron ${target}`);
            await install();
            await exec('npx electron-builder install-app-deps');
            const table = new Map([
                ['mac',     'npx electron-builder --mac --universal --publish always'],
                ['windows', 'npx electron-builder --win --x64 --arm64 --publish always'],
                ['linux',   'npx electron-builder --linux --publish always']
            ]);
            const targets = table.has(key) ? [table.get(key)] : Array.from(table.values());
            for (const target of targets) {
                /* eslint-disable no-await-in-loop */
                await exec(target);
                /* eslint-enable no-await-in-loop */
            }
            break;
        }
        case 'python': {
            writeLine('publish python');
            await build('python');
            await exec('python -m pip install --user twine');
            await exec('python -m twine upload --non-interactive --skip-existing --verbose dist/pypi/*.whl');
            break;
        }
        case 'cask': {
            writeLine('publish cask');
            await fork('Homebrew', 'homebrew-cask');
            const repository = `https://github.com/${configuration.repository}`;
            const url = `${repository}/releases/download/v#{version}/${configuration.productName}-#{version}-mac.zip`;
            const sha256 = await hash(url.replace(/#{version}/g, configuration.version), 'sha256');
            writeLine('update manifest');
            const dir = await mkdir('dist', 'homebrew-cask', 'Casks', 'n');
            const file = path.join(dir, 'netron.rb');
            await fs.writeFile(file, [
                `cask "${configuration.name}" do`,
                `  version "${configuration.version}"`,
                `  sha256 "${sha256.toLowerCase()}"`,
                '',
                `  url "${url}"`,
                `  name "${configuration.productName}"`,
                `  desc "${configuration.description.replace('Visualizer', 'Visualiser')}"`,
                `  homepage "${repository}"`,
                '',
                '  auto_updates true',
                '',
                `  app "${configuration.productName}.app"`,
                '',
                '  zap trash: [',
                `    "~/Library/Application Support/${configuration.productName}",`,
                `    "~/Library/Preferences/${configuration.build.appId}.plist",`,
                `    "~/Library/Saved Application State/${configuration.build.appId}.savedState",`,
                '  ]',
                'end',
                ''
            ].join('\n'));
            writeLine('git push homebrew-cask');
            await exec('git -C dist/homebrew-cask add --all');
            await exec(`git -C dist/homebrew-cask commit -m "${configuration.name} ${configuration.version}"`);
            await pullrequest('Homebrew', 'homebrew-cask', process.env.GITHUB_TOKEN, {
                title: `${configuration.name} ${configuration.version}`,
                body: 'Update version and sha256',
                head: `${process.env.GITHUB_USER}:master`,
                base: 'master'
            });
            await rm('dist', 'homebrew-cask');
            break;
        }
        case 'winget': {
            writeLine('publish winget');
            await fork('microsoft', 'winget-pkgs');
            const name = configuration.name;
            const version = configuration.version;
            const product = configuration.productName;
            const publisher = configuration.author.name;
            const identifier = `${publisher.replace(' ', '')}.${product}`;
            const copyright = `Copyright (c) ${publisher}`;
            const repository = `https://github.com/${configuration.repository}`;
            const url = `${repository}/releases/download/v${version}/${product}-Setup-${version}.exe`;
            const content = await fs.readFile(configuration.build.extends, 'utf-8');
            const builder = JSON.parse(content);
            const extensions = builder.fileAssociations.map((entry) => `- ${entry.ext}`).sort().join('\n');
            const sha256 = await hash(url, 'sha256');
            const paths = ['dist', 'winget-pkgs', 'manifests', publisher[0].toLowerCase(), publisher.replace(' ', ''), product, version];
            await mkdir(...paths);
            writeLine('update manifest');
            const manifestFile = dirname(...paths, identifier);
            await fs.writeFile(`${manifestFile}.yaml`, [
                '# yaml-language-server: $schema=https://aka.ms/winget-manifest.version.1.6.0.schema.json',
                `PackageIdentifier: ${identifier}`,
                `PackageVersion: ${version}`,
                'DefaultLocale: en-US',
                'ManifestType: version',
                'ManifestVersion: 1.6.0',
                ''
            ].join('\n'));
            await fs.writeFile(`${manifestFile}.installer.yaml`, [
                '# yaml-language-server: $schema=https://aka.ms/winget-manifest.installer.1.6.0.schema.json',
                `PackageIdentifier: ${identifier}`,
                `PackageVersion: ${version}`,
                'Platform:',
                '- Windows.Desktop',
                'InstallModes:',
                '- silent',
                '- silentWithProgress',
                'Installers:',
                '- Architecture: x86',
                '  Scope: user',
                '  InstallerType: nullsoft',
                `  InstallerUrl: ${url}`,
                `  InstallerSha256: ${sha256.toUpperCase()}`,
                '  InstallerLocale: en-US',
                '  InstallerSwitches:',
                '    Custom: /NORESTART',
                '  UpgradeBehavior: install',
                '- Architecture: arm64',
                '  Scope: user',
                '  InstallerType: nullsoft',
                `  InstallerUrl: ${url}`,
                `  InstallerSha256: ${sha256.toUpperCase()}`,
                '  InstallerLocale: en-US',
                '  InstallerSwitches:',
                '    Custom: /NORESTART',
                '  UpgradeBehavior: install',
                'FileExtensions:',
                extensions,
                'ManifestType: installer',
                'ManifestVersion: 1.6.0',
                ''
            ].join('\n'));
            await fs.writeFile(`${manifestFile}.locale.en-US.yaml`, [
                '# yaml-language-server: $schema=https://aka.ms/winget-manifest.defaultLocale.1.6.0.schema.json',
                `PackageIdentifier: ${identifier}`,
                `PackageVersion: ${version}`,
                `PackageName: ${product}`,
                'PackageLocale: en-US',
                `PackageUrl: ${repository}`,
                `Publisher: ${publisher}`,
                `PublisherUrl: ${repository}`,
                `PublisherSupportUrl: ${repository}/issues`,
                `Author: ${publisher}`,
                `License: ${configuration.license}`,
                `Copyright: ${copyright}`,
                `CopyrightUrl: ${repository}/blob/main/LICENSE`,
                `ShortDescription: ${configuration.description}`,
                `Description: ${configuration.description}`,
                `Moniker: ${name}`,
                'Tags:',
                '- machine-learning',
                '- deep-learning',
                '- neural-network',
                'ManifestType: defaultLocale',
                'ManifestVersion: 1.6.0',
                ''
            ].join('\n'));
            writeLine('git push winget-pkgs');
            await exec('git -C dist/winget-pkgs add --all');
            await exec(`git -C dist/winget-pkgs commit -m "Update ${configuration.name} to ${configuration.version}"`);
            await pullrequest('microsoft', 'winget-pkgs', process.env.WINGET_TOKEN, {
                title: `Update ${configuration.productName} to ${configuration.version}`,
                body: '',
                head: `${process.env.GITHUB_USER}:master`,
                base: 'master'
            });
            await rm('dist', 'winget-pkgs');
            break;
        }
        default: {
            writeLine('publish');
            await rm('dist');
            await install();
            await publish('web');
            await publish('electron');
            await publish('python');
            await publish('cask');
            await publish('winget');
            break;
        }
    }
};

const lint = async () => {
    await install();
    writeLine('eslint');
    await exec('npx eslint --cache --cache-location ./dist/lint/.eslintcache');
    writeLine('ruff');
    await exec('python -m ruff check . --quiet');
};

const test = async (target) => {
    let models = true;
    while (true) {
        /* eslint-disable no-await-in-loop */
        if (target === 'desktop' || read('desktop')) {
            target = null;
            models = false;
            await exec('npx playwright install --with-deps');
            const host = process.platform === 'linux' && (process.env.GITHUB_ACTIONS || process.env.CI) ? 'xvfb-run -a ' : '';
            await exec(`${host}npx playwright test --config=test/playwright.config.js --project=desktop`);
            continue;
        }
        if (target === 'browser' || read('browser')) {
            target = null;
            models = false;
            if (process.platform !== 'win32') {
                await exec('npx playwright install --with-deps');
                const headed = process.env.GITHUB_ACTIONS || process.env.CI ? '' :  ' --headed';
                await exec(`npx playwright test --config=test/playwright.config.js --project=browser${headed}`);
            }
            continue;
        }
        break;
        /* eslint-enable no-await-in-loop */
    }
    if (models) {
        target = target || args.join(' ');
        await exec(`node test/models.js ${target}`);
    }
};

const validate = async () => {
    writeLine('lint');
    await lint();
    writeLine('test');
    await test('tag:validation');
    writeLine('test desktop');
    await test('desktop');
    writeLine('test browser');
    await test('browser');
};

const update = async () => {
    const filter = new Set(process.argv.length > 3 ? process.argv.slice(3) : []);
    if (filter.size === 0) {
        const output = await exec('npm outdated --json', 'utf-8');
        const entries = JSON.parse(output.stdout);
        const compare = (a, b) => {
            const regex = /^\d+\.\d+\.\d+$/;
            if (!regex.test(a)) {
                throw new Error(`Invalid version format '${a}'.`);
            }
            if (!regex.test(b)) {
                throw new Error(`Invalid version format '${b}'.`);
            }
            a = a.split('.').map((v) => Number(v));
            b = b.split('.').map((v) => Number(v));
            if (a.length !== b.length) {
                throw new Error(`Invalid version a=${a.join('.')} b=${b.join('.')}`);
            }
            for (let i = 0; i < 3; i++) {
                if ((a[i] || 0) > (b[i] || 0)) {
                    return 1;
                }
                if ((a[i] || 0) < (b[i] || 0)) {
                    return -1;
                }
            }
            return 0;
        };
        for (const [name, entry] of Object.entries(entries)) {
            if (compare(entry.wanted, entry.latest) < 0) {
                writeLine(name);
                /* eslint-disable no-await-in-loop */
                await exec(`npm install --quiet --no-progress --silent --save-exact ${name}@latest`);
                /* eslint-enable no-await-in-loop */
            }
        }
    }
    let targets = [
        'armnn',
        'bigdl',
        'caffe', 'circle', 'cntk', 'coreml',
        'dlc', 'dnn',
        'espdl', 'executorch',
        'gguf',
        'kann', 'keras',
        'mlir', 'mnn', 'mslite', 'megengine',
        'nnabla',
        'onnx', 'om',
        'paddle', 'pytorch',
        'rknn',
        'sentencepiece', 'sklearn',
        'tf', 'tosa',
        'uff',
        'xmodel'
    ];
    let commands = [
        'sync',
        'install',
        'schema',
        'metadata'
    ];
    if (filter.size > 0 && targets.some((target) => filter.has(target))) {
        targets = targets.filter((target) => filter.has(target));
    }
    if (filter.size > 0 && commands.some((target) => filter.has(target))) {
        commands = commands.filter((command) => filter.has(command));
    }
    commands = commands.join(' ');
    for (const target of targets) {
        /* eslint-disable no-await-in-loop */
        await exec(`tools/${target} ${commands}`);
        /* eslint-enable no-await-in-loop */
    }
};

const pull = async () => {
    await exec('git fetch --prune origin "refs/tags/*:refs/tags/*"');
    let before = await exec('git rev-parse HEAD', 'utf-8');
    if (before.status !== 0) {
        throw new Error(before.stderr.trim());
    }
    try {
        await exec('git pull --prune --rebase --autostash');
    } catch (error) {
        writeLine(error.message);
    }
    let after = await exec('git rev-parse HEAD', 'utf-8');
    if (after.status !== 0) {
        throw new Error(after.stderr.trim());
    }
    before = before.stdout.trim();
    after = after.stdout.trim();
    if (before !== after) {
        const output = await exec(`git diff --name-only ${before} ${after}`, 'utf-8');
        const files = new Set(output.stdout.split('\n'));
        if (files.has('package.json')) {
            await clean();
            await install();
        }
    }
};

const coverage = async () => {
    switch (read()) {
        case 'desktop': {
            await rm('dist', 'nyc');
            await mkdir('dist', 'nyc');
            await exec('cp package.json dist/nyc');
            await exec('cp -R source dist/nyc');
            await exec('nyc instrument --compact false source dist/nyc/source');
            const file = dirname('dist', 'nyc', 'source', 'index.html');
            let content = await fs.readFile(file, 'utf-8');
            content = content.replace(`"script-src 'self'"`, `"script-src 'self' 'unsafe-eval'"`);
            await fs.writeFile(file, content, 'utf-8');
            await exec('nyc --instrument npx electron ./dist/nyc');
            await exec('nyc report');
            break;
        }
        case 'test': {
            const target = args.join(' ');
            await rm('dist', 'c8');
            await exec(`npx c8 --reporter=html --report-dir=dist/c8/report node test/models.js ${target}`);
            break;
        }
        default: {
            throw new Error('Unsupported coverage target.');
        }
    }
};

const analyze = async () => {
    const exists = await access('third_party/tools/codeql');
    if (!exists) {
        await exec('git clone --depth=1 https://github.com/github/codeql.git third_party/tools/codeql');
    }
    await rm('dist', 'codeql');
    await mkdir('dist', 'codeql', 'netron');
    await exec('cp -r publish source test tools dist/codeql/netron/');
    await exec('codeql database create dist/codeql/database --source-root dist/codeql/netron --language=javascript --threads=3');
    await exec('codeql database analyze dist/codeql/database ./third_party/tools/codeql/javascript/ql/src/codeql-suites/javascript-security-and-quality.qls --format=csv --output=dist/codeql/results.csv --threads=3');
    await exec('cat dist/codeql/results.csv');
};

const version = async () => {
    await pull();
    const file = dirname('package.json');
    let content = await fs.readFile(file, 'utf-8');
    content = content.replace(/(\s*"version":\s")(\d\.\d\.\d)(",)/m, (match, p1, p2, p3) => {
        const version = Array.from((parseInt(p2.split('.').join(''), 10) + 1).toString()).join('.');
        return p1 + version + p3;
    });
    content = content.replace(/(\s*"date":\s")(.*)(",)/m, (match, p1, p2, p3) => {
        const date = new Date().toISOString().split('.').shift().split('T').join(' ');
        return p1 + date + p3;
    });
    await fs.writeFile(file, content, 'utf-8');
    await exec('npm install --package-lock-only');
    await load();
    await exec('git add package.json');
    await exec('git add package-lock.json');
    await exec(`git commit -m "Update to ${configuration.version}"`);
    await exec(`git tag v${configuration.version}`);
    await exec('git push');
    await exec('git push --tags');
};

const main = async () => {
    await load();
    try {
        const task = read();
        switch (task) {
            case 'start': await start(); break;
            case 'clean': await clean(); break;
            case 'install': await install(); break;
            case 'build': await build(); break;
            case 'publish': await publish(); break;
            case 'version': await version(); break;
            case 'lint': await lint(); break;
            case 'test': await test(); break;
            case 'validate': await validate(); break;
            case 'update': await update(); break;
            case 'pull': await pull(); break;
            case 'analyze': await analyze(); break;
            case 'coverage': await coverage(); break;
            default: throw new Error(`Unsupported task '${task}'.`);
        }
    } catch (error) {
        if (process.stdout.write) {
            process.stdout.write(error.message + os.EOL);
        }
        process.exit(1);
    }
};

await main();


================================================
FILE: package.json
================================================
{
    "name": "netron",
    "productName": "Netron",
    "author": {
        "name": "Lutz Roeder",
        "email": "lutzroeder@users.noreply.github.com",
        "url": "https://www.lutzroeder.com"
    },
    "version": "8.9.5",
    "date": "2026-03-13 14:03:12",
    "description": "Visualizer for neural network, deep learning, and machine learning models",
    "license": "MIT",
    "repository": "lutzroeder/netron",
    "type": "module",
    "main": "source/app.js",
    "scripts": {
        "start": "node package.js start",
        "server": "python package.py build start",
        "clean": "node package.js clean",
        "install": "node package.js install",
        "lint": "node package.js lint",
        "build": "node package.js build",
        "publish": "node package.js publish",
        "version": "node package.js version",
        "test": "node package.js test",
        "validate": "node package.js validate",
        "coverage": "node package.js coverage",
        "analyze": "node package.js analyze",
        "update": "node package.js update",
        "pull": "node package.js pull"
    },
    "dependencies": {
        "electron-updater": "6.8.3"
    },
    "devDependencies": {
        "@electron/notarize": "3.1.1",
        "@playwright/test": "1.58.2",
        "electron": "41.0.3",
        "electron-builder": "26.8.1",
        "eslint": "10.0.3"
    },
    "build": {
        "extends": "publish/electron-builder.json"
    },
    "nyc": {
        "reporter": [
            "lcov",
            "html"
        ],
        "report-dir": "dist/nyc/report",
        "temp-dir": "dist/nyc/.nyc_output"
    }
}


================================================
FILE: package.py
================================================
import os
import sys

argv = sys.argv[1:]

root_dir = os.path.dirname(os.path.abspath(__file__))
dist_dir = os.path.join(root_dir, "dist")
dist_pypi_dir = os.path.join(dist_dir, "pypi")

def _build():
    import shutil
    source_dir = os.path.join(root_dir, "source")
    shutil.rmtree(os.path.join(source_dir, "__pycache__"), ignore_errors=True)
    shutil.rmtree(dist_pypi_dir, ignore_errors=True)
    shutil.copytree(source_dir, os.path.join(dist_pypi_dir, "netron"))
    shutil.copyfile(
        os.path.join(root_dir, "pyproject.toml"),
        os.path.join(dist_pypi_dir, "pyproject.toml"))
    os.remove(os.path.join(dist_pypi_dir, "netron", "desktop.mjs"))
    os.remove(os.path.join(dist_pypi_dir, "netron", "app.js"))

def _install():
    import pip._internal.cli.main
    pip._internal.cli.main.main(["install", dist_pypi_dir])

def _version():
    import json
    import re
    path = os.path.join(root_dir, "package.json")
    with open(path, encoding="utf-8") as file:
        package = json.load(file)
    version = package["version"]
    date = package["date"]
    entries = [
        ("pyproject.toml", '(version\\s*=\\s*")(.*)(")', version),
        ("netron/server.py", '(__version__\\s=\\s")(.*)(")', version),
        ("netron/index.html", '(<meta name="version" content=")(.*)(">)', version),
        ("netron/index.html", '(<meta name="date" content=")(.*)(">)', date)
    ]
    for path, regex, value in entries:
        path = os.path.join(dist_pypi_dir, path)
        with open(path, encoding="utf-8") as file:
            content = file.read()
        content, count = re.subn(regex, rf"\g<1>{value}\g<3>", content)
        if count == 0:
            raise ValueError(f"Failed to update '{path}' with '{value}'.")
        with open(path, "w", encoding="utf-8") as file:
            file.write(content)

def _start():
    """ Start server """
    sys.path.insert(0, os.path.join(root_dir, "dist", "pypi"))
    __import__("netron").main()
    argv.clear()

def main():
    table = {
        "build": _build,
        "install": _install,
        "version": _version,
        "start": _start
    }
    while len(argv) > 0:
        command = argv.pop(0)
        del sys.argv[1]
        table[command]()

if __name__ == "__main__":
    main()


================================================
FILE: publish/electron-builder.json
================================================
{
    "appId": "com.lutzroeder.netron",
    "productName": "Netron",
    "files": [ "source/**/*" ],
    "directories": { "buildResources": "./publish" },
    "fileAssociations": [
        { "ext": "armnn",       "name": "Arm NN Model"             },
        { "ext": "caffemodel",  "name": "Caffe Model"              },
        { "ext": "circle",      "name": "Circle Model"             },
        { "ext": "ckpt",        "name": "Model Checkpoint"         },
        { "ext": "cmf",         "name": "CNTK Model"               },
        { "ext": "dlc",         "name": "DLC Model"                },
        { "ext": "dnn",         "name": "CNTK Model"               },
        { "ext": "espdl",       "name": "ESP-DL Model"              },
        { "ext": "gguf",        "name": "GGUF Model"               },
        { "ext": "h5",          "name": "Keras Model"              },
        { "ext": "hd5",         "name": "Keras Model"              },
        { "ext": "hdf5",        "name": "Keras Model"              },
        { "ext": "hn",          "name": "Hailo Model"              },
        { "ext": "kann",        "name": "KaNN Model"               },
        { "ext": "kgraph",      "name": "KaNN Model"               },
        { "ext": "keras",       "name": "Keras Model"              },
        { "ext": "kmodel",      "name": "Kendryte Model"           },
        { "ext": "lite",        "name": "TensorFlow Lite Model"    },
        { "ext": "mar",         "name": "MXNet Model"              },
        { "ext": "maxviz",      "name": "Modular Model"            },
        { "ext": "meta",        "name": "TensorFlow Meta Graph"    },
        { "ext": "mge",         "name": "MegEngine Mge Model"      },
        { "ext": "mlmodel",     "name": "Core ML Model"            },
        { "ext": "mlir",        "name": "MLIR Model"               },
        { "ext": "mlirbc",      "name": "MLIR Bytecode Model"      },
        { "ext": "mlnet",       "name": "ML.NET Model"             },
        { "ext": "mlpackage",   "name": "Core ML Model Package", "isPackage": true },
        { "ext": "mnn",         "name": "MNN Model"                },
        { "ext": "model",       "name": "Model"                    },
        { "ext": "nb",          "name": "Paddle Lite Model"        },
        { "ext": "ngf",         "name": "ONNX Model"               },
        { "ext": "nn",          "name": "Barracuda Model"          },
        { "ext": "nnp",         "name": "Neural Network Libraries" },
        { "ext": "npy",         "name": "NumPy Array"              },
        { "ext": "npz",         "name": "NumPy Archive"            },
        { "ext": "om",          "name": "DaVinci OM Model"         },
        { "ext": "onnx",        "name": "ONNX Model"               },
        { "ext": "ort",         "name": "ONNX Runtime Model"       },
        { "ext": "paddle",      "name": "PaddlePaddle Model"       },
        { "ext": "param",       "name": "NCNN Model"               },
        { "ext": "pb",          "name": "Protocol Buffer"          },
        { "ext": "pbtxt",       "name": "Text Protocol Buffer"     },
        { "ext": "pdiparams",   "name": "PaddlePaddle Model"       },
        { "ext": "pdmodel",     "name": "PaddlePaddle Model"       },
        { "ext": "pdopt",       "name": "PaddlePaddle Model"       },
        { "ext": "pdparams",    "name": "PaddlePaddle Model"       },
        { "ext": "pickle",      "name": "Python Pickle File"       },
        { "ext": "pkl",         "name": "Python Pickle File"       },
        { "ext": "prototxt",    "name": "Text Protocol Buffer"     },
        { "ext": "pt",          "name": "PyTorch Model"            },
        { "ext": "pt2",         "name": "PyTorch Model"            },
        { "ext": "pte",         "name": "ExecuTorch Model"         },
        { "ext": "pth",         "name": "PyTorch Model"            },
        { "ext": "ptl",         "name": "PyTorch Model"            },
        { "ext": "rknn",        "name": "RKNN Model"               },
        { "ext": "safetensors", "name": "Safetensors Checkpoint"   },
        { "ext": "t7",          "name": "Torch Model"              },
        { "ext": "tfl",         "name": "TensorFlow Lite Model"    },
        { "ext": "tflite",      "name": "TensorFlow Lite Model"    },
        { "ext": "tmfile",      "name": "Tengine Model"            },
        { "ext": "tm",          "name": "MegEngine Traced Model"   },
        { "ext": "tnnproto",    "name": "TNN Model"                },
        { "ext": "tosa",        "name": "TOSA Model"               },
        { "ext": "torchscript", "name": "PyTorch Model"            },
        { "ext": "uff",         "name": "UFF Model"                },
        { "ext": "xmodel",      "name": "Vitis AI Model"           }
    ],
    "publish": [
        { "provider": "github", "releaseType": "release" }
    ],
    "linux": {
        "artifactName":"${productName}-${version}-${arch}.${ext}",
        "executableName": "netron",
        "target": [ 
            { "target": "deb", "arch": ["x64"] },
            { "target": "rpm", "arch": ["x64"] }
        ]
    },
    "mac": {
        "artifactName": "${productName}-${version}-mac.${ext}",
        "category": "public.app-category.developer-tools",
        "darkModeSupport": true,
        "gatekeeperAssess": false,
        "hardenedRuntime": true,
        "notarize": true,
        "target": [ "dmg", "zip" ]
    },
    "win": {
        "target": [ "nsis" ],
        "azureSignOptions" : {
            "publisherName": "Lutz Roeder",
            "endpoint": "https://eus.codesigning.azure.net/",
            "codeSigningAccountName": "lutzroeder",
            "certificateProfileName": "lutzroeder"
        }
    },
    "dmg": {
        "artifactName": "${productName}-${version}.${ext}",
        "title": "${productName} ${version}",
        "writeUpdateInfo": false,
        "iconSize": 160,
        "contents": [
            { "x": 180, "y": 170 },
            { "x": 480, "y": 170, "type": "link", "path": "/Applications" }
        ]
    },
    "nsis": {
        "differentialPackage": false
    }
}


================================================
FILE: publish/icon.html
================================================
<!DOCTYPE html>
<html>
<body>
<div style="height: 400px;">
<div style="background: #f6f6f6; width: 400px; height: 400px; float: left;"> 
<img src="icon.svg" width="300" style="position: relative; top: 50px; left: 50px;">
</div>
<div style="background: #d8d8d8; width: 400px; height: 400px; float: left;"> 
<img src="icon.svg" width="300" style="position: relative; top: 50px; left: 50px;">
</div>
<div style="background: #1e1e1e; width: 400px; height: 400px; float: left;"> 
<img src="icon.svg" width="300" style="position: relative; top: 50px; left: 50px;">
</div>
</div>
<div style="height: 400px;">
<div style="background: #f6f6f6; width: 400px; height: 400px; float: left;"> 
<img src="icon.icns.svg" width="300" style="position: relative; top: 50px; left: 50px;">
</div>
<div style="background: #d8d8d8; width: 400px; height: 400px; float: left;">
<img src="icon.icns.svg" width="300" style="position: relative; top: 50px; left: 50px;">
</div>
<div style="background: #1e1e1e; width: 400px; height: 400px; float: left;"> 
<img src="icon.icns.svg" width="300" style="position: relative; top: 50px; left: 50px;">
</div>
</div>
</body>
</html>

================================================
FILE: pyproject.toml
================================================

[build-system]
requires = ["setuptools>=42", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "netron"
version = "0.0.0"
description = "Viewer for neural network, deep learning and machine learning models."
authors = [
    { name = "Lutz Roeder", email = "lutzroeder@users.noreply.github.com" }
]
keywords = [
    "onnx", "keras", "tensorflow", "tflite", "coreml", "mxnet", "caffe", "caffe2",
    "torchscript", "pytorch", "ncnn", "mnn", "openvino", "darknet", "paddlepaddle", "chainer",
    "artificial intelligence", "machine learning", "deep learning", "neural network",
    "visualizer", "viewer"
]
classifiers = [
    "Intended Audience :: Developers",
    "Intended Audience :: Education",
    "Intended Audience :: Science/Research",
    "Programming Language :: Python :: 3",
    "Programming Language :: Python :: 3.6",
    "Topic :: Software Development",
    "Topic :: Software Development :: Libraries",
    "Topic :: Software Development :: Libraries :: Python Modules",
    "Topic :: Scientific/Engineering",
    "Topic :: Scientific/Engineering :: Mathematics",
    "Topic :: Scientific/Engineering :: Artificial Intelligence",
    "Topic :: Scientific/Engineering :: Visualization"
]

[project.urls]
homepage = "https://github.com/lutzroeder/netron"

[project.readme]
text = """
Netron is a viewer for neural network, deep learning and machine learning models.

Netron supports ONNX, TensorFlow Lite, Core ML, Keras, Caffe, Darknet, PyTorch, TensorFlow.js, Safetensors and NumPy.

Netron has experimental support for TorchScript, torch.export, ExecuTorch, TensorFlow, OpenVINO, RKNN, ncnn, MNN, PaddlePaddle, GGUF and scikit-learn.
"""
content-type = "text/markdown"

[project.license]
text = "MIT"

[project.scripts]
netron = "netron:main"

[tool.setuptools]
package-dir = { "netron" = "netron" }

[tool.setuptools.packages.find]
namespaces = false

[tool.setuptools.package-data]
netron = ["*.*"]

[tool.setuptools.exclude-package-data]
netron = ["app.js", "electron.*"]

[tool.ruff]
lint.select = ["B", "E", "F", "I", "UP", "W", "Q"]
cache-dir = "./dist/lint/.ruff_cache"

================================================
FILE: source/__init__.py
================================================
""" Python Server entry point """

import argparse
import logging
import os
import sys

from .server import __version__, serve, start, status, stop, wait, widget

__all__ = ["start", "stop", "status", "wait", "serve", "widget", "__version__"]

def main():
    """ main entry point """
    parser = argparse.ArgumentParser(description=
        "Viewer for neural network, deep learning and machine learning models.")
    parser.add_argument("file",
        metavar="MODEL_FILE", help="model file to serve", nargs="?", default=None)
    parser.add_argument("-b", "--browse",
        help="launch web browser", action="store_true")
    parser.add_argument("-p", "--port", help="port to serve", type=int)
    parser.add_argument("--host",
        metavar="ADDR", help="host to serve", default="localhost")
    parser.add_argument("--verbosity",
        metavar="LEVEL", help="log verbosity (quiet, default, debug)",
        choices=[ "quiet", "debug", "default" ], default="default")
    parser.add_argument("--version", help="print version", action="store_true")
    args = parser.parse_args()
    levels = {
        "quiet": logging.CRITICAL,
        "default": logging.INFO,
        "debug": logging.DEBUG,
    }
    logging.basicConfig(level=levels[args.verbosity], format="%(message)s")
    logger = logging.getLogger(__name__)
    if args.file and not os.path.exists(args.file):
        logger.error(f"Model file '{args.file}' does not exist.")
        sys.exit(2)
    if args.version:
        logger.info(__version__)
        sys.exit(0)
    address = (args.host, args.port) if args.host else args.port if args.port else None
    start(args.file, address=address, browse=args.browse)
    wait()
    sys.exit(0)

if __name__ == "__main__":
    main()


================================================
FILE: source/acuity-metadata.json
================================================
[
  {
    "name": "a_times_b_plus_c",
    "inputs": [
      { "name": "A" },
      { "name": "B" },
      { "name": "C" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "abs",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "acosh",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "activity_regularization",
    "attributes": [
      { "name": "l1", "default": 0.0 },
      { "name": "l2", "default": 0.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "add",
    "inputs": [
      { "name": "A" },
      { "name": "B" }
    ],
    "outputs": [
      { "name": "C" }
    ]
  },
  {
    "name": "addn",
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "additive_attention",
    "category": "Attention",
    "attributes": [
      { "name": "use_scale", "default": true },
      { "name": "dropout", "default": 0.0 }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" },
      { "name": "input2" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "alpha_dropout",
    "category": "Dropout",
    "attributes": [
      { "name": "rate", "default": 0.1 },
      { "name": "seed", "default": 0.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "argmin",
    "attributes": [
      { "name": "axis", "default": -1 },
      { "name": "keepdims", "default": false },
      { "name": "select_last_index", "default": false },
      { "name": "output_type", "default": "int64" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "atan",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "atan2",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "atanh",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "attention",
    "category": "Attention",
    "attributes": [
      { "name": "use_scale", "default": true },
      { "name": "dropout", "default": 0.0 },
      { "name": "score_mode", "default": "dot" }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "average",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "base_input_layer",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "batch2space",
    "attributes": [
      { "name": "block_shape", "default": [2, 2] },
      { "name": "block_crops", "default": [[0, 0], [0, 0]] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "batch2space_op",
    "attributes": [
      { "name": "block_shape", "default": [2] },
      { "name": "block_crops", "default": [[0, 1]] }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "batchnorm_single",
    "category": "Normalization",
    "attributes": [
      { "name": "eps", "default": 0.0001 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "mean" },
      { "name": "variance" }
    ],
    "constants": [
      { "name": "bias" },
      { "name": "scale" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "batchnormalize",
    "category": "Normalization",
    "attributes": [
      { "name": "eps", "default": 0.0001 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "beta" },
      { "name": "gamma" },
      { "name": "mean" },
      { "name": "variance" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "bitwise_and",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "bitwise_or",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "bitwise_xor",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "broadcast_args",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "bucketize",
    "attributes": [
      { "name": "right", "default": false },
      { "name": "out_type", "default": "uint32" }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "ctc_loss_layer",
    "attributes": [
      { "name": "time_major", "default": false }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "capsule_norm",
    "category": "Normalization",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "cast",
    "category": "Quantization",
    "attributes": [
      { "name": "in_data_type", "default": 0 },
      { "name": "out_data_type", "default": 0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "ceil",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "celu",
    "category": "Activation",
    "attributes": [
      { "name": "alpha", "default": 1.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "center_crop_pad",
    "attributes": [
      { "name": "shape", "default": [] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "clipbyvalue",
    "attributes": [
      { "name": "clip_value_min", "default": 0 },
      { "name": "clip_value_max", "default": 255 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "col2im",
    "attributes": [
      { "name": "image_shape", "default": [] },
      { "name": "block_shape", "default": [] },
      { "name": "pads", "default": [[0, 0], [0, 0]] },
      { "name": "strides", "default": [1, 1] },
      { "name": "dilations", "default": [1, 1] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "concat",
    "category": "Tensor",
    "attributes": [
      { "name": "dim", "default": 1 }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "concatshift",
    "category": "Tensor",
    "attributes": [
      { "name": "dim", "default": 1 },
      { "name": "keep_size", "default": 1 }
    ],
    "outputs": [
      { "name": "data" },
      { "name": "shifted_data" }
    ]
  },
  {
    "name": "continuationindicator",
    "attributes": [
      { "name": "time_step", "default": 0 },
      { "name": "batch_size", "default": 0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "conv1d",
    "category": "Layer",
    "attributes": [
      { "name": "padding_mode", "default": "CONSTANT" },
      { "name": "weights", "default": 1 },
      { "name": "padding", "default": "VALID" },
      { "name": "bias", "default": true },
      { "name": "group_number", "default": 1 },
      { "name": "ksize", "default": 1 },
      { "name": "stride", "default": 1 },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0] },
      { "name": "pad_method", "default": "auto" },
      { "name": "dilation", "default": [1, 1, 1] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "conv1d_winograd",
    "category": "Layer",
    "attributes": [
      { "name": "padding_mode", "default": "CONSTANT" },
      { "name": "weights", "default": 1 },
      { "name": "padding", "default": "VALID" },
      { "name": "bias", "default": true },
      { "name": "group_number", "default": 1 },
      { "name": "ksize", "default": 1 },
      { "name": "stride", "default": 1 },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0] },
      { "name": "pad_method", "default": "auto" },
      { "name": "dilation", "default": [1, 1, 1] },
      { "name": "wino_n", "default": 2 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" },
      { "name": "AT" },
      { "name": "G" },
      { "name": "BT" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "conv2d_lstm",
    "category": "Layer",
    "attributes": [
      { "name": "filters", "default": 1 },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "dilation", "default": [1, 1, 1, 1] },
      { "name": "pad_method", "default": "auto" },
      { "name": "padding", "default": "VALID" },
      { "name": "pad", "default": [0, 0, 0, 0] },
      { "name": "data_format", "default": "channels_last" },
      { "name": "return_sequences", "default": true },
      { "name": "recurrent_activation", "default": "hard_sigmoid" },
      { "name": "activation", "default": "tanh" }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" },
      { "name": "input2" }
    ],
    "constants": [
      { "name": "ki" },
      { "name": "kf" },
      { "name": "kc" },
      { "name": "ko" },
      { "name": "ri" },
      { "name": "rf" },
      { "name": "rc" },
      { "name": "ro" },
      { "name": "bi" },
      { "name": "bf" },
      { "name": "bc" },
      { "name": "bo" }
    ],
    "outputs": [
      { "name": "output0" },
      { "name": "output1" },
      { "name": "output2" }
    ]
  },
  {
    "name": "conv2d_op",
    "category": "Layer",
    "attributes": [
      { "name": "padding_mode", "default": "CONSTANT" },
      { "name": "padding", "default": "VALID" },
      { "name": "group_number", "default": 1 },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "pad_h", "default": 0 },
      { "name": "pad_w", "default": 0 },
      { "name": "dilation", "default": [1, 1, 1, 1] },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0] },
      { "name": "pad_h_b", "default": 0 },
      { "name": "pad_w_r", "default": 0 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "conv3d",
    "category": "Layer",
    "attributes": [
      { "name": "padding_mode", "default": "CONSTANT" },
      { "name": "weights", "default": 1 },
      { "name": "bias", "default": false },
      { "name": "group_number", "default": 1 },
      { "name": "ksize_d", "default": 1 },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_d", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "padding", "default": "VALID" },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0, 0, 0] },
      { "name": "dilation", "default": [1, 1, 1, 1, 1] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "convolution",
    "category": "Layer",
    "attributes": [
      { "name": "padding_mode", "default": "CONSTANT" },
      { "name": "weights", "default": 1 },
      { "name": "padding", "default": "VALID" },
      { "name": "bias", "default": true },
      { "name": "group_number", "default": 1 },
      { "name": "regularize", "default": false },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "pad_h", "default": 0 },
      { "name": "pad_w", "default": 0 },
      { "name": "dilation", "default": [1, 1, 1, 1] },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0] },
      { "name": "pad_h_b", "default": 0 },
      { "name": "pad_w_r", "default": 0 },
      { "name": "multiplier", "default": 0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "cos",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "cropandresize",
    "attributes": [
      { "name": "num_crop_boxes", "default": 0 },
      { "name": "crop_size", "default": [] },
      { "name": "resize_method", "default": "bilinear" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "boxes" },
      { "name": "box_ind" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "crop_image",
    "attributes": [
      { "name": "crop_size", "default": [] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "cumsum",
    "attributes": [
      { "name": "axis", "default": 0 },
      { "name": "exclusive", "default": false },
      { "name": "reverse", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "customlayer"
  },
  {
    "name": "dft",
    "attributes": [
      { "name": "axis", "default": "1" },
      { "name": "inverse", "default": "0" },
      { "name": "onesided", "default": "0" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "deconvolution",
    "category": "Layer",
    "attributes": [
      { "name": "weights", "default": 1 },
      { "name": "padding", "default": "VALID" },
      { "name": "bias", "default": true },
      { "name": "group_number", "default": 1 },
      { "name": "regularize", "default": false },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "pad_h", "default": 0 },
      { "name": "pad_w", "default": 0 },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0] },
      { "name": "pad_h_b", "default": 0 },
      { "name": "pad_w_r", "default": 0 },
      { "name": "output_shape", "default": [] },
      { "name": "output_padding_h", "default": 0 },
      { "name": "output_padding_w", "default": 0 }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "deconvolution1d",
    "category": "Layer",
    "attributes": [
      { "name": "weights", "default": 1 },
      { "name": "padding", "default": "VALID" },
      { "name": "bias", "default": true },
      { "name": "group_number", "default": 1 },
      { "name": "ksize", "default": 1 },
      { "name": "stride", "default": 1 },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0] },
      { "name": "dilation", "default": [1] },
      { "name": "output_shape", "default": [] },
      { "name": "output_padding", "default": 0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "deconvolution_op",
    "category": "Layer",
    "attributes": [
      { "name": "padding", "default": "VALID" },
      { "name": "group_number", "default": 1 },
      { "name": "regularize", "default": false },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "pad_h", "default": 0 },
      { "name": "pad_w", "default": 0 },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0,  0] },
      { "name": "pad_h_b", "default": 0 },
      { "name": "pad_w_r", "default": 0 },
      { "name": "output_shape", "default": [] },
      { "name": "output_padding_h", "default": 0 },
      { "name": "output_padding_w", "default": 0 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "weight" },
      { "name": "output_shape" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "deconvolution3d",
    "category": "Layer",
    "attributes": [
      { "name": "weights", "default": 1 },
      { "name": "bias", "default": false },
      { "name": "group_number", "default": 1 },
      { "name": "ksize_d", "default": 1 },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_d", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "padding", "default": "VALID" },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0, 0, 0] },
      { "name": "pad_d_d", "default": 0 },
      { "name": "pad_h_b", "default": 0 },
      { "name": "pad_w_r", "default": 0 },
      { "name": "output_shape", "default": [] },
      { "name": "output_padding_d", "default": 0 },
      { "name": "output_padding_h", "default": 0 },
      { "name": "output_padding_w", "default": 0 }
    ],
    "inputs": [
      { "name": "data" },
      { "name": "output_shape" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "depth2space",
    "attributes": [
      { "name": "block_size", "default": 2 },
      { "name": "mode", "default": "DCR" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "depthwise_conv1d",
    "category": "Layer",
    "attributes": [
      { "name": "padding_mode", "default": "CONSTANT" },
      { "name": "weights", "default": 1 },
      { "name": "padding", "default": "VALID" },
      { "name": "bias", "default": true },
      { "name": "group_number", "default": 2 },
      { "name": "ksize", "default": 1 },
      { "name": "stride", "default": 1 },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0] },
      { "name": "dilation", "default": [1, 1, 1] },
      { "name": "multiplier", "default": 1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "depthwise_conv2d_op",
    "category": "Layer",
    "attributes": [
      { "name": "padding_mode", "default": "CONSTANT" },
      { "name": "padding", "default": "VALID" },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "dilation", "default": [1, 1, 1, 1] },
      { "name": "multiplier", "default": 1 },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0] },
      { "name": "pad_h", "default": 0 },
      { "name": "pad_w", "default": 0 },
      { "name": "pad_h_b", "default": 0 },
      { "name": "pad_w_r", "default": 0 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "weight" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "depthwise_convolution",
    "category": "Layer",
    "attributes": [
      { "name": "padding_mode", "default": "CONSTANT" },
      { "name": "weights", "default": 1 },
      { "name": "padding", "default": "VALID" },
      { "name": "bias", "default": true },
      { "name": "regularize", "default": false },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "dilation", "default": [1, 1, 1, 1] },
      { "name": "multiplier", "default": 1 },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0] },
      { "name": "pad_h", "default": 0 },
      { "name": "pad_w", "default": 0 },
      { "name": "pad_h_b", "default": 0 },
      { "name": "pad_w_r", "default": 0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "dequantize",
    "category": "Quantization",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "detectionevaluate",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output0" },
      { "name": "output1" },
      { "name": "output2" },
      { "name": "output3" },
      { "name": "output4" }
    ]
  },
  {
    "name": "detectionoutput",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" },
      { "name": "input2" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "digit_capsule",
    "attributes": [
      { "name": "num_output", "default": 1 },
      { "name": "vec_len", "default": 1 },
      { "name": "iterations", "default": 3 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "Divide",
    "inputs": [
      { "name": "dividend" },
      { "name": "divisor" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "dropout",
    "category": "Dropout",
    "attributes": [
      { "name": "ratio", "default": 0.5 },
      { "name": "scale_train", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "dropout2",
    "category": "Dropout",
    "attributes": [
      { "name": "ratio", "default": 0.5 },
      { "name": "scale_train", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "dtype_converter",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "einsum",
    "attributes": [
      { "name": "equation", "default": "" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "eltwise",
    "attributes": [
      { "name": "operation", "default": "SUM" },
      { "name": "coeff", "default": "1.0" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "elu",
    "category": "Activation",
    "attributes": [
      { "name": "alpha", "default": 1.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "embedding_lookup",
    "attributes": [
      { "name": "partition_strategy", "default": "mod" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "embedding_params" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "equal",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "erf",
    "category": "Activation",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "exp",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "expand_broadcast",
    "attributes": [
      { "name": "shape", "default": [] }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "ExpandDims",
    "category": "Shape",
    "attributes": [
      { "name": "dim", "default": 0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "fill",
    "inputs": [
      { "name": "input" },
      { "name": "fill_value" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "flatten",
    "category": "Shape",
    "attributes": [
      { "name": "axis", "default": 1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "floor",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "floor_div",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "fullconnect",
    "category": "Layer",
    "attributes": [
      { "name": "weights", "default": 1 },
      { "name": "bias", "default": true },
      { "name": "regularize", "default": false },
      { "name": "axis", "default": 1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "fullconnect_op",
    "category": "Layer",
    "attributes": [
      { "name": "weights", "default": 1 },
      { "name": "bias", "default": true },
      { "name": "axis", "default": 1 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "weights" }
    ],
    "constants": [
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "gru",
    "category": "Layer",
    "attributes": [
      { "name": "num_units", "default": 1 },
      { "name": "time_major", "default": true },
      { "name": "activation", "default": "tanh" },
      { "name": "recurrent_activation", "default": "sigmoid" },
      { "name": "return_sequences", "default": true },
      { "name": "reset_after", "default": true },
      { "name": "implementation", "default": 2 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "hidden_states" }
    ],
    "constants": [
      { "name": "k_iz" },
      { "name": "k_ir" },
      { "name": "k_ih" },
      { "name": "k_rz" },
      { "name": "k_rr" },
      { "name": "k_rh" },
      { "name": "b_iz" },
      { "name": "b_ir" },
      { "name": "b_ih" },
      { "name": "b_rz" },
      { "name": "b_rr" },
      { "name": "b_rh" }
    ],
    "outputs": [
      { "name": "output" },
      { "name": "hidden_states" }
    ]
  },
  {
    "name": "gru_cell",
    "category": "Layer",
    "attributes": [
      { "name": "num_units", "default": 1 },
      { "name": "activation", "default": "tanh" },
      { "name": "recurrent_activation", "default": "sigmoid" },
      { "name": "reset_after", "default": true },
      { "name": "implementation", "default": 2 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "hidden_states" }
    ],
    "constants": [
      { "name": "k_iz" },
      { "name": "k_ir" },
      { "name": "k_ih" },
      { "name": "k_rz" },
      { "name": "k_rr" },
      { "name": "k_rh" },
      { "name": "b_iz" },
      { "name": "b_ir" },
      { "name": "b_ih" },
      { "name": "b_rz" },
      { "name": "b_rr" },
      { "name": "b_rh" }
    ],
    "outputs": [
      { "name": "output" },
      { "name": "hidden_states" }
    ]
  },
  {
    "name": "gather",
    "category": "Transform",
    "attributes": [
      { "name": "axis", "default": 0 },
      { "name": "batch_dims", "default": null }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "gather_elements",
    "attributes": [
      { "name": "axis", "default": 0 }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "gathernd",
    "attributes": [
      { "name": "batch_dims", "default": 0 }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "gelu",
    "category": "Activation",
    "attributes": [
      { "name": "approximate", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "greater",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "greater_equal",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "gridsample",
    "attributes": [
      { "name": "mode", "default": "bilinear" },
      { "name": "padding_mode", "default": "zeros" },
      { "name": "align_corners", "default": false }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "group_conv1d",
    "category": "Layer",
    "attributes": [
      { "name": "padding_mode", "default": "CONSTANT" },
      { "name": "weights", "default": 1 },
      { "name": "padding", "default": "VALID" },
      { "name": "bias", "default": true },
      { "name": "group_number", "default": 2 },
      { "name": "ksize", "default": 1 },
      { "name": "stride", "default": 1 },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0] },
      { "name": "dilation", "default": [1, 1, 1] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "groupnormalize",
    "category": "Normalization",
    "attributes": [
      { "name": "eps", "default": 0.0001 },
      { "name": "num_groups", "default": 1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "bias" },
      { "name": "scale" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "hammingwindow",
    "attributes": [
      { "name": "out_data_type", "default": 1 },
      { "name": "periodic", "default": 1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "hannwindow",
    "attributes": [
      { "name": "out_data_type", "default": 1 },
      { "name": "periodic", "default": 1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "hard_sigmoid",
    "category": "Activation",
    "attributes": [
      { "name": "alpha", "default": 0.2 },
      { "name": "beta", "default": 0.5 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "hard_swish",
    "category": "Activation",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "image_resize",
    "attributes": [
      { "name": "type", "default": "bilinear" },
      { "name": "new_size", "default": [] },
      { "name": "align_corners", "default": false },
      { "name": "half_pixel", "default": false },
      { "name": "size_factors", "default": null },
      { "name": "layout", "default": null }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "image_transform",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "in_topk",
    "attributes": [
      { "name": "topk", "default": 1 }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "input",
    "attributes": [
      { "name": "size", "default": "" },
      { "name": "channels", "default": 1 },
      { "name": "shape", "default": [] },
      { "name": "is_scalar", "default": false },
      { "name": "type", "default": "float32" },
      { "name": "merge_permute", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "instancenormalize",
    "category": "Normalization",
    "attributes": [
      { "name": "eps", "default": 0.0001 },
      { "name": "axis", "default": [] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "bias" },
      { "name": "scale" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "inverse_sigmoid",
    "category": "Activation",
    "attributes": [
      { "name": "eps", "default": 1e-05 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "keras_rnn_lstm",
    "category": "Layer",
    "attributes": [
      { "name": "cell", "default": null },
      { "name": "go_backwards", "default": false },
      { "name": "return_sequences", "default": false },
      { "name": "return_state", "default": false },
      { "name": "stateful", "default": false },
      { "name": "unroll", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "kernel" },
      { "name": "recurrent_kernel" },
      { "name": "bias" }
    ]
  },
  {
    "name": "l1_layernormalize",
    "category": "Normalization",
    "attributes": [
      { "name": "axis", "default": -1 },
      { "name": "eps", "default": 0.0001 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "scale" },
      { "name": "bias" },
      { "name": "gamma" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "l2normalize",
    "category": "Normalization",
    "attributes": [
      { "name": "l2n_dim", "default": null },
      { "name": "eps", "default": 1e-12 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "l2normalizescale",
    "category": "Normalization",
    "attributes": [
      { "name": "l2n_dim", "default": null },
      { "name": "eps", "default": 1e-12 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "scale" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "l2pooling",
    "category": "Pool",
    "attributes": [
      { "name": "padding", "default": "VALID" },
      { "name": "type", "default": "MAX" },
      { "name": "global_pooling", "default": false },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "pad_h", "default": 0 },
      { "name": "pad_w", "default": 0 },
      { "name": "round_type", "default": "ceil" },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0] },
      { "name": "pad_h_b", "default": 0 },
      { "name": "pad_w_r", "default": 0 },
      { "name": "count_include_pad", "default": 1 },
      { "name": "dilation", "default": [1, 1, 1, 1] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "lstm",
    "category": "Layer",
    "attributes": [
      { "name": "weights", "default": 1 },
      { "name": "time_major", "default": true },
      { "name": "forget_bias", "default": 1.0 },
      { "name": "activation", "default": "tanh" },
      { "name": "use_layer_norm_lstm", "default": false },
      { "name": "use_cifg", "default": false },
      { "name": "use_peepholes", "default": false },
      { "name": "num_proj", "default": null },
      { "name": "cell_clip", "default": 0.0 },
      { "name": "proj_clip", "default": 0.0 },
      { "name": "recurrent_activation", "default": "sigmoid" },
      { "name": "return_sequences", "default": true },
      { "name": "peephole", "default": true }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "hidden_states" },
      { "name": "cell_states" }
    ],
    "constants": [
      { "name": "wi" },
      { "name": "wf" },
      { "name": "wc" },
      { "name": "wo" },
      { "name": "hi" },
      { "name": "hf" },
      { "name": "hc" },
      { "name": "ho" },
      { "name": "bi" },
      { "name": "bf" },
      { "name": "bc" },
      { "name": "bo" },
      { "name": "wp" },
      { "name": "bp" },
      { "name": "ci" },
      { "name": "cf" },
      { "name": "co" },
      { "name": "ln_i" },
      { "name": "ln_f" },
      { "name": "ln_c" },
      { "name": "ln_o" }
    ],
    "outputs": [
      { "name": "output" },
      { "name": "hidden_states" },
      { "name": "cell_states" }
    ]
  },
  {
    "name": "lstm_base",
    "category": "Layer",
    "inputs": [
      { "name": "input" },
      { "name": "hidden_states" },
      { "name": "cell_states" }
    ],
    "constants": [
      { "name": "wi" },
      { "name": "wf" },
      { "name": "wc" },
      { "name": "wo" },
      { "name": "hi" },
      { "name": "hf" },
      { "name": "hc" },
      { "name": "ho" },
      { "name": "bi" },
      { "name": "bf" },
      { "name": "bc" },
      { "name": "bo" },
      { "name": "wp" },
      { "name": "bp" },
      { "name": "ci" },
      { "name": "cf" },
      { "name": "co" },
      { "name": "ln_i" },
      { "name": "ln_f" },
      { "name": "ln_c" },
      { "name": "ln_o" }
    ],
    "outputs": [
      { "name": "output" },
      { "name": "hidden_states" },
      { "name": "cell_states" }
    ]
  },
  {
    "name": "lstmunit",
    "category": "Layer",
    "attributes": [
      { "name": "weights", "default": 1 },
      { "name": "num_proj", "default": null },
      { "name": "forget_bias", "default": 1.0 },
      { "name": "cell_clip", "default": 0.0 },
      { "name": "proj_clip", "default": 0.0 },
      { "name": "activation", "default": "tanh" },
      { "name": "use_layer_norm_lstm", "default": false },
      { "name": "use_cifg", "default": false },
      { "name": "use_peepholes", "default": false }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "hidden_states" },
      { "name": "cell_states" }
    ],
    "constants": [
      { "name": "wi" },
      { "name": "wf" },
      { "name": "wc" },
      { "name": "wo" },
      { "name": "hi" },
      { "name": "hf" },
      { "name": "hc" },
      { "name": "ho" },
      { "name": "bi" },
      { "name": "bf" },
      { "name": "bc" },
      { "name": "bo" },
      { "name": "wp" },
      { "name": "bp" },
      { "name": "ci" },
      { "name": "cf" },
      { "name": "co" },
      { "name": "ln_i" },
      { "name": "ln_f" },
      { "name": "ln_c" },
      { "name": "ln_o" }
    ],
    "outputs": [
      { "name": "output" },
      { "name": "hidden_states" },
      { "name": "cell_states" }
    ]
  },
  {
    "name": "lstm_keras",
    "category": "Layer",
    "attributes": [
      { "name": "units", "default": 1 },
      { "name": "activation", "default": "tanh" },
      { "name": "recurrent_activation", "default": "hard_sigmoid" },
      { "name": "use_bias", "default": true },
      { "name": "return_sequences", "default": false },
      { "name": "return_state", "default": false },
      { "name": "go_backwards", "default": false },
      { "name": "stateful", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "kernel" },
      { "name": "recurrent_kernel" },
      { "name": "bias" }
    ]
  },
  {
    "name": "layernormalize",
    "category": "Normalization",
    "attributes": [
      { "name": "axis_list", "default": [-1] },
      { "name": "eps", "default": 0.0001 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "bias" },
      { "name": "scale" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "leakyrelu",
    "category": "Activation",
    "attributes": [
      { "name": "leaky_ratio", "default": 0.1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "less",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "less_equal",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "LocalResponseNormalization",
    "category": "Normalization",
    "attributes": [
      { "name": "local_size", "default": 1 },
      { "name": "bias", "default": 2.0 },
      { "name": "alpha", "default": 0.0001 },
      { "name": "beta", "default": 0.75 },
      { "name": "type", "default": "NORM_ACROSS_CHANNELS" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "LocalResponseNormalization_tf",
    "category": "Normalization",
    "attributes": [
      { "name": "local_size", "default": 1 },
      { "name": "bias", "default": 2.0 },
      { "name": "alpha", "default": 0.0001 },
      { "name": "beta", "default": 0.75 },
      { "name": "type", "default": "NORM_ACROSS_CHANNELS" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "log",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "log_softmax",
    "category": "Activation",
    "attributes": [
      { "name": "sf_axis", "default": -1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "logical_and",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "logical_not",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "logical_or",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "logical_xor",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "loop",
    "attributes": [
      { "name": "body", "default": null },
      { "name": "max_iterations", "default": null }
    ]
  },
  {
    "name": "margin_loss_layer",
    "attributes": [
      { "name": "margin", "default": 0.4 },
      { "name": "downweight", "default": 0.5 }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "mat_inverse",
    "attributes": [
      { "name": "adjoint", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "matmul",
    "attributes": [
      { "name": "transpose_a", "default": false },
      { "name": "transpose_b", "default": false }
    ],
    "inputs": [
      { "name": "a" },
      { "name": "b" }
    ],
    "outputs": [
      { "name": "c" }
    ]
  },
  {
    "name": "minimum",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "minimum_with_clip",
    "attributes": [
      { "name": "clip", "default": 1.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "mish",
    "category": "Activation",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "mod",
    "attributes": [
      { "name": "fmod", "default": 0 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "mod" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "moments",
    "attributes": [
      { "name": "axis_list", "default": [] },
      { "name": "keep_dims", "default": true }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "mean" },
      { "name": "variance" }
    ]
  },
  {
    "name": "multiply",
    "attributes": [
      { "name": "axis", "default": 1 },
      { "name": "bias", "default": false }
    ],
    "constants": [
      { "name": "scale" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "nms",
    "attributes": [
      { "name": "max_output_size", "default": 100 },
      { "name": "iou_threshold", "default": 0.5 },
      { "name": "score_threshold", "default": 0.5 },
      { "name": "soft_nms_sigma", "default": 0.0 },
      { "name": "pad_to_max_output_size", "default": true }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output0" },
      { "name": "output1" },
      { "name": "output2" }
    ]
  },
  {
    "name": "noop",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "nce_loss",
    "attributes": [
      { "name": "num_sampled", "default": 1 },
      { "name": "num_classes", "default": 1 }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "neg",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "nonzero",
    "attributes": [
      { "name": "output_type", "default": "int64" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "noop_multi_out",
    "inputs": [
      { "name": "input" }
    ]
  },
  {
    "name": "norm_with_channel_mean",
    "category": "Normalization",
    "attributes": [
      { "name": "mean", "default": [] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "norm_with_min_max",
    "category": "Normalization",
    "attributes": [
      { "name": "min_value", "default": 0.0 },
      { "name": "max_value", "default": 1.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "norm_with_scale",
    "category": "Normalization",
    "attributes": [
      { "name": "scale", "default": 1.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "not_equal",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "one_hot",
    "attributes": [
      { "name": "depth", "default": 1 },
      { "name": "on_value", "default": 1 },
      { "name": "off_value", "default": 0 },
      { "name": "axis", "default": -1 },
      { "name": "dtype", "default": "float32" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "output",
    "attributes": [
      { "name": "merge_permute", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "prelu",
    "category": "Activation",
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "a" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "pad",
    "attributes": [
      { "name": "padding_value", "default": [] },
      { "name": "padding_mode", "default": "CONSTANT" },
      { "name": "padding_const", "default": 0 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "pad_value" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "permute",
    "attributes": [
      { "name": "perm", "default": [0] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "pooling",
    "category": "Pool",
    "attributes": [
      { "name": "padding", "default": "VALID" },
      { "name": "type", "default": "MAX" },
      { "name": "global_pooling", "default": false },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "pad_h", "default": 0 },
      { "name": "pad_w", "default": 0 },
      { "name": "round_type", "default": "ceil" },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0] },
      { "name": "pad_h_b", "default": 0 },
      { "name": "pad_w_r", "default": 0 },
      { "name": "count_include_pad", "default": 1 },
      { "name": "dilation", "default": [1, 1, 1, 1] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "pool1d",
    "category": "Pool",
    "attributes": [
      { "name": "padding", "default": "VALID" },
      { "name": "type", "default": "MAX" },
      { "name": "global_pooling", "default": false },
      { "name": "ksize", "default": 1 },
      { "name": "stride", "default": 1 },
      { "name": "round_type", "default": "ceil" },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0] },
      { "name": "dilation", "default": 1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "pool3d",
    "category": "Pool",
    "attributes": [
      { "name": "padding", "default": "VALID" },
      { "name": "type", "default": "MAX" },
      { "name": "global_pooling", "default": false },
      { "name": "ksize_d", "default": 1 },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_d", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "pad_d", "default": 0 },
      { "name": "pad_h", "default": 0 },
      { "name": "pad_w", "default": 0 },
      { "name": "round_type", "default": "floor" },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0, 0, 0] },
      { "name": "count_include_pad", "default": 0 },
      { "name": "dilation", "default": [1, 1, 1, 1, 1] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "poolwithargmax",
    "category": "Pool",
    "attributes": [
      { "name": "padding", "default": "VALID" },
      { "name": "type", "default": "MAX" },
      { "name": "global_pooling", "default": false },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "pad_h", "default": 0 },
      { "name": "pad_w", "default": 0 },
      { "name": "round_type", "default": "ceil" },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0] },
      { "name": "pad_h_b", "default": 0 },
      { "name": "pad_w_r", "default": 0 },
      { "name": "count_include_pad", "default": 1 },
      { "name": "dilation", "default": [1, 1, 1, 1] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output0" },
      { "name": "output1" }
    ]
  },
  {
    "name": "pow",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "preprocess",
    "attributes": [
      { "name": "type", "default": "VSI_NN_OP_PRE_PROCESS_RGB" },
      { "name": "left", "default": 0 },
      { "name": "top", "default": 0 },
      { "name": "width", "default": 244 },
      { "name": "height", "default": 224 },
      { "name": "mean", "default": [0, 0, 0] },
      { "name": "scale", "default": 1 },
      { "name": "perm", "default": [0, 1, 2, 3] },
      { "name": "in_dim_num", "default": 4 },
      { "name": "out_dim_num", "default": 4 },
      { "name": "out_size", "default": [224, 224, 3, 1] },
      { "name": "reverse_channel", "default": 1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "primary_capsule",
    "attributes": [
      { "name": "num_output", "default": 1 },
      { "name": "vec_len", "default": 1 },
      { "name": "strides", "default": [1, 1] },
      { "name": "ksize", "default": [1, 1] },
      { "name": "padding", "default": "SAME" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "priorbox",
    "attributes": [
      { "name": "mini_size", "default": "" },
      { "name": "max_size", "default": "" },
      { "name": "aspect_ratio", "default": "" },
      { "name": "flip", "default": "" },
      { "name": "clip", "default": "" },
      { "name": "variance", "default": "0.1" },
      { "name": "image_size", "default": 0 },
      { "name": "image_h", "default": 0 },
      { "name": "image_w", "default": 0 },
      { "name": "step", "default": 0.0 },
      { "name": "step_h", "default": 0.0 },
      { "name": "step_w", "default": 0.0 },
      { "name": "offset", "default": 0.5 }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "Proposal",
    "attributes": [
      { "name": "feat_stride", "default": 16 },
      { "name": "anchor_scales", "default": "8 16 32" },
      { "name": "anchor_ratios", "default": "0.5 1 2" },
      { "name": "anchor_base_size", "default": 16 },
      { "name": "pre_nms_top_n", "default": 6000 },
      { "name": "post_nms_top_n", "default": 300 },
      { "name": "nms_thresh", "default": 0.7 },
      { "name": "min_size", "default": 16 },
      { "name": "im_info", "default": "800 600 1 1" },
      { "name": "has_bg", "default": true },
      { "name": "dynamic", "default": false }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output0" },
      { "name": "output1" }
    ]
  },
  {
    "name": "quantize",
    "category": "Quantization",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "rmsnormalize",
    "category": "Normalization",
    "attributes": [
      { "name": "axis", "default": -1 },
      { "name": "eps", "default": 0.0001 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "scale" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "roipooling",
    "category": "Pool",
    "attributes": [
      { "name": "pooled_h", "default": 6 },
      { "name": "pooled_w", "default": 6 },
      { "name": "spatial_scale", "default": 0.0625 },
      { "name": "sampling_ratio", "default": 0.0 }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "range",
    "attributes": [
      { "name": "start", "default": 0 },
      { "name": "limit", "default": -1 },
      { "name": "delta", "default": 1 },
      { "name": "dtype", "default": "int32" }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" },
      { "name": "input2" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "rank",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reorg",
    "attributes": [
      { "name": "stride", "default": 2 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "real_div",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reconstruction_loss",
    "attributes": [
      { "name": "balance_factor", "default": 0.0005 }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "recurrent",
    "category": "Layer",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reduceany",
    "attributes": [
      { "name": "axis_list", "default": null },
      { "name": "keep_dims", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reducel2",
    "attributes": [
      { "name": "axis_list", "default": [] },
      { "name": "keep_dims", "default": true }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reducemax",
    "attributes": [
      { "name": "axis_list", "default": null },
      { "name": "keep_dims", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reducemean",
    "attributes": [
      { "name": "axis_list", "default": null },
      { "name": "keep_dims", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reducemin",
    "attributes": [
      { "name": "axis_list", "default": null },
      { "name": "keep_dims", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reduceprod",
    "attributes": [
      { "name": "axis_list", "default": [] },
      { "name": "keep_dims", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reducesum",
    "attributes": [
      { "name": "axis_list", "default": [] },
      { "name": "keep_dims", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "region",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "relu",
    "category": "Activation",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "relun",
    "category": "Activation",
    "attributes": [
      { "name": "relu_clamp_top", "default": "inf" },
      { "name": "relu_clamp_bottom", "default": 0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "relu_keras",
    "category": "Activation",
    "attributes": [
      { "name": "alpha", "default": 0.0 },
      { "name": "max_value", "default": "inf" },
      { "name": "threshold", "default": 0.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "repeat",
    "attributes": [
      { "name": "maxlen", "default": 0 },
      { "name": "axis", "default": null }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "times" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reshape",
    "category": "Shape",
    "attributes": [
      { "name": "shape", "default": [] }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "new_shape" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "resizebilinear_image",
    "attributes": [
      { "name": "new_size", "default": [] },
      { "name": "align_corners", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "resizenearest_image",
    "attributes": [
      { "name": "new_size", "default": [] },
      { "name": "align_corners", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reverse",
    "attributes": [
      { "name": "axis", "default": [] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "reverse_sequence",
    "attributes": [
      { "name": "seq_axis", "default": 1 },
      { "name": "batch_axis", "default": 2 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "seq_lengths" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "round",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "route_train",
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "rsqrt",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "stft",
    "attributes": [
      { "name": "onesided", "default": "1" }
    ],
    "inputs": [
      { "name": "signal" },
      { "name": "step" },
      { "name": "window" },
      { "name": "length" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "svdf",
    "attributes": [
      { "name": "rank", "default": 1 },
      { "name": "num_units", "default": 1 },
      { "name": "spectrogram_length", "default": 1 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "state" }
    ],
    "constants": [
      { "name": "weights_feature" },
      { "name": "weights_time" },
      { "name": "bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "space2batch",
    "attributes": [
      { "name": "block_shape", "default": [2, 2] },
      { "name": "block_paddings", "default": [[0, 0], [0, 0]] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "space2batch_op",
    "attributes": [
      { "name": "block_shape", "default": [2] },
      { "name": "block_paddings", "default": [[0, 1]] }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "block_paddings" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "space2depth",
    "attributes": [
      { "name": "block_size", "default": [] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "scatter_elements",
    "attributes": [
      { "name": "axis", "default": 0 },
      { "name": "reduction", "default": "none" }
    ],
    "inputs": [
      { "name": "data" },
      { "name": "indices" },
      { "name": "updates" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "scatternd",
    "attributes": [
      { "name": "shape", "default": [] }
    ],
    "inputs": [
      { "name": "indices" },
      { "name": "updates" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "scatter_nd_update",
    "attributes": [
      { "name": "reduction", "default": "none" }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "indices" },
      { "name": "updates" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "segment_sum",
    "attributes": [
      { "name": "segment_ids", "default": [] }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "selu",
    "category": "Activation",
    "attributes": [
      { "name": "alpha", "default": 1.68 },
      { "name": "gamma", "default": 1.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "sequence_mask",
    "attributes": [
      { "name": "maxlen", "default": 50 },
      { "name": "dtype", "default": "bool" }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "seq" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "shapelayer",
    "attributes": [
      { "name": "out_type", "default": "int32" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "shuffle",
    "attributes": [
      { "name": "group_number", "default": 1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "sigmoid",
    "category": "Activation",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "sign",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "signalframe",
    "attributes": [
      { "name": "frame_length", "default": 0 },
      { "name": "frame_step", "default": 0 },
      { "name": "pad_end", "default": false },
      { "name": "pad_value", "default": 0 },
      { "name": "axis", "default": -1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "simplernn_keras",
    "attributes": [
      { "name": "units", "default": 1 },
      { "name": "activation", "default": "tanh" },
      { "name": "use_bias", "default": true },
      { "name": "return_sequences", "default": false },
      { "name": "return_state", "default": false },
      { "name": "go_backwards", "default": false },
      { "name": "stateful", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "kernel" },
      { "name": "recurrent_kernel" },
      { "name": "bias" }
    ]
  },
  {
    "name": "sin",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "size",
    "attributes": [
      { "name": "out_type", "default": "int32" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "slice",
    "category": "Tensor",
    "attributes": [
      { "name": "begin", "default": [] },
      { "name": "size", "default": [] }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "begin" },
      { "name": "size" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "slice_op",
    "attributes": [
      { "name": "axes", "default": [] },
      { "name": "steps", "default": [] }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "starts" },
      { "name": "ends" },
      { "name": "axes" },
      { "name": "steps" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "softmax",
    "category": "Activation",
    "attributes": [
      { "name": "sf_axis", "default": -1 },
      { "name": "beta", "default": 1.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "softrelu",
    "category": "Activation",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "softmax_with_logits_loss_layer",
    "category": "Activation",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "sparse_to_dense",
    "attributes": [
      { "name": "output_shape", "default": [] },
      { "name": "default_value", "default": 0 },
      { "name": "validate_indices", "default": true }
    ],
    "inputs": [
      { "name": "sparse_indices" },
      { "name": "sparse_value" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "split",
    "category": "Tensor",
    "attributes": [
      { "name": "dim", "default": 1 },
      { "name": "slices", "default": [] },
      { "name": "slices_tf", "default": [] },
      { "name": "unstack", "default": false }
    ],
    "inputs": [
      { "name": "input" }
    ]
  },
  {
    "name": "sqrt",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "square",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "squared_difference",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "squashing",
    "category": "Reduce",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "squeeze",
    "category": "Shape",
    "attributes": [
      { "name": "axis_list", "default": null },
      { "name": "name", "default": null }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "stack",
    "attributes": [
      { "name": "axis", "default": 0 }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "stack_concat",
    "attributes": [
      { "name": "shape", "default": [1, 32, 256] },
      { "name": "axis", "default": 1 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "index" },
      { "name": "state" }
    ],
    "outputs": [
      { "name": "output" },
      { "name": "state" }
    ]
  },
  {
    "name": "stridedslice",
    "attributes": [
      { "name": "slice_begin_mask", "default": 0 },
      { "name": "slice_end_mask", "default": 0 },
      { "name": "slice_ellipsis_mask", "default": 0 },
      { "name": "slice_new_axis_mask", "default": 0 },
      { "name": "slice_shrink_axis_mask", "default": 0 },
      { "name": "slice_begin", "default": [] },
      { "name": "slice_end", "default": [] },
      { "name": "slice_strides", "default": [] }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "slice_begin" },
      { "name": "slice_end" },
      { "name": "slice_strides" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "subgraph",
    "attributes": [
      { "name": "sg_argv", "default": "" },
      { "name": "sg_func", "default": "" },
      { "name": "sg_out_shapes", "default": "" },
      { "name": "sg_graph_buffer", "default": "" },
      { "name": "sg_input_nodes", "default": "" },
      { "name": "sg_output_nodes", "default": "" }
    ]
  },
  {
    "name": "Subtract",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "swish",
    "attributes": [
      { "name": "beta", "default": 1.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "tan",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "tanh",
    "attributes": [
      { "name": "hyperbolic_tan_scale_a", "default": 1.0 },
      { "name": "hyperbolic_tan_scale_b", "default": 1.0 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "tile",
    "attributes": [
      { "name": "multiples", "default": [] }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "repeats" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "topk",
    "attributes": [
      { "name": "k", "default": 1 },
      { "name": "axis", "default": -1 }
    ],
    "inputs": [
      { "name": "input" },
      { "name": "k" }
    ],
    "outputs": [
      { "name": "output0" },
      { "name": "output1" }
    ]
  },
  {
    "name": "topk_score",
    "attributes": [
      { "name": "topk", "default": 1 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output0" },
      { "name": "output1" }
    ]
  },
  {
    "name": "transform_unit",
    "attributes": [
      { "name": "heads_num", "default": 1 },
      { "name": "axis_list", "default": [-1] },
      { "name": "eps", "default": 0.0001 },
      { "name": "shape", "default": [] },
      { "name": "fc_weights", "default": 1 },
      { "name": "fc_bias", "default": true },
      { "name": "fc_regularize", "default": false },
      { "name": "fc_axis", "default": 1 },
      { "name": "shape_1", "default": [] },
      { "name": "dim", "default": 1 },
      { "name": "slices", "default": [] },
      { "name": "slices_tf", "default": [] },
      { "name": "unstack", "default": false },
      { "name": "shape_Q", "default": [] },
      { "name": "shape_K", "default": [] },
      { "name": "shape_V", "default": [] },
      { "name": "perm_Q", "default": [0] },
      { "name": "perm_K", "default": [0] },
      { "name": "perm_V", "default": [0] },
      { "name": "transpose_a", "default": false },
      { "name": "transpose_b", "default": false },
      { "name": "mul_axis", "default": 1 },
      { "name": "mul_bias", "default": true },
      { "name": "sf_axis", "default": -1 },
      { "name": "beta", "default": 1.0 },
      { "name": "transpose_a_1", "default": false },
      { "name": "transpose_b_1", "default": false },
      { "name": "perm", "default": [0] },
      { "name": "shape_2", "default": [] },
      { "name": "shape_3", "default": [] },
      { "name": "fc2_weights", "default": 1 },
      { "name": "fc2_bias", "default": true },
      { "name": "fc2_regularize", "default": false },
      { "name": "fc2_axis", "default": 1 },
      { "name": "shape_4", "default": [] },
      { "name": "ln2_axis_list", "default": [-1] },
      { "name": "ln2_eps", "default": 0.0001 },
      { "name": "shape_5", "default": [] },
      { "name": "fc3_weights", "default": 1 },
      { "name": "fc3_bias", "default": true },
      { "name": "fc3_regularize", "default": false },
      { "name": "fc3_axis", "default": 1 },
      { "name": "shape_6", "default": [] },
      { "name": "approximate", "default": false },
      { "name": "shape_7", "default": [] },
      { "name": "fc4_weights", "default": 1 },
      { "name": "fc4_bias", "default": true },
      { "name": "fc4_regularize", "default": false },
      { "name": "fc4_axis", "default": 1 },
      { "name": "shape_8", "default": [] }
    ],
    "inputs": [
      { "name": "input0" },
      { "name": "input1" }
    ],
    "constants": [
      { "name": "ln_scale" },
      { "name": "ln_bias" },
      { "name": "fc_weight" },
      { "name": "fc_bias" },
      { "name": "fc2_weight" },
      { "name": "fc2_bias" },
      { "name": "ln2_scale" },
      { "name": "ln2_bias" },
      { "name": "fc3_weight" },
      { "name": "fc3_bias" },
      { "name": "fc4_weight" },
      { "name": "fc4_bias" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "unstack",
    "attributes": [
      { "name": "axis", "default": 1 }
    ],
    "inputs": [
      { "name": "input" }
    ]
  },
  {
    "name": "upsampling3d",
    "attributes": [
      { "name": "size", "default": true }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "upsampling",
    "attributes": [
      { "name": "factor", "default": 2 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "variable",
    "category": "Data",
    "attributes": [
      { "name": "shape", "default": [1] },
      { "name": "is_scalar", "default": false },
      { "name": "type", "default": "float32" }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "data" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "where",
    "inputs": [
      { "name": "input0" },
      { "name": "input1" },
      { "name": "input2" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "while_loop",
    "attributes": [
      { "name": "cond", "default": null },
      { "name": "body", "default": null },
      { "name": "max_iterations", "default": null }
    ]
  },
  {
    "name": "yolo",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "yoloprocess",
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "zeros_like",
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "conv2d_winograd",
    "category": "Layer",
    "attributes": [
      { "name": "padding_mode", "default": "CONSTANT" },
      { "name": "weights", "default": 1 },
      { "name": "padding", "default": "VALID" },
      { "name": "bias", "default": true },
      { "name": "group_number", "default": 1 },
      { "name": "regularize", "default": false },
      { "name": "ksize_h", "default": 1 },
      { "name": "ksize_w", "default": 1 },
      { "name": "stride_h", "default": 1 },
      { "name": "stride_w", "default": 1 },
      { "name": "pad_h", "default": 0 },
      { "name": "pad_w", "default": 0 },
      { "name": "dilation", "default": [1, 1, 1, 1] },
      { "name": "pad_method", "default": "auto" },
      { "name": "pad", "default": [0, 0, 0, 0] },
      { "name": "pad_h_b", "default": 0 },
      { "name": "pad_w_r", "default": 0 },
      { "name": "multiplier", "default": 0 },
      { "name": "wino_n", "default": 2 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "constants": [
      { "name": "weight" },
      { "name": "bias" },
      { "name": "AT" },
      { "name": "G" },
      { "name": "BT" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  },
  {
    "name": "postprocess",
    "attributes": [
      { "name": "perm", "default": [0, 1, 2, 3] },
      { "name": "dim_num", "default": 4 }
    ],
    "inputs": [
      { "name": "input" }
    ],
    "outputs": [
      { "name": "output" }
    ]
  }
]

================================================
FILE: source/acuity.js
================================================

const acuity = {};

acuity.ModelFactory = class {

    async match(context) {
        const obj = await context.peek('json');
        if (obj && obj.MetaData && obj.Layers && Object.keys(obj).length < 256) {
            return context.set('acuity', obj);
        }
        return null;
    }

    async open(context) {
        const metadata = await context.metadata('acuity-metadata.json');
        return new acuity.Model(metadata, context.value);
    }
};

acuity.Model = class {

    constructor(metadata, model, data, quantization) {
        this.name = model.MetaData.Name;
        this.format = `Acuity${model.MetaData && model.MetaData.AcuityVersion ? ` v${model.MetaData.AcuityVersion}` : ''}`;
        this.runtime = model.MetaData.Platform;
        this.modules = [new acuity.Graph(metadata, model, data, quantization)];
    }
};

acuity.Graph = class {

    constructor(metadata, model) {
        this.nodes = [];
        this.inputs = [];
        this.outputs = [];
        this.metrics = [];
        const values = new Map();
        const value = (name) => {
            if (!values.has(name)) {
                values.set(name, { name, shape: null });
            }
            return values.get(name);
        };
        let totalFlops = 0;
        for (const [name, layer] of Object.entries(model.Layers)) {
            layer.inputs = layer.inputs.map((input) => {
                return value(input);
            });
            layer.outputs = layer.outputs.map((port) => {
                const output = value(`@${name}:${port}`);
                let shape = null;
                if (layer.op.toLowerCase() === 'input' ||
                    layer.op.toLowerCase() === 'variable') {
                    if (Object.prototype.hasOwnProperty.call(layer.parameters, 'shape') && layer.parameters.shape.length > 0) {
                        shape = layer.parameters.shape;
                    } else if (Object.prototype.hasOwnProperty.call(layer.parameters, 'size') && Object.prototype.hasOwnProperty.call(layer.parameters, 'channels')) {
                        const sizes = layer.parameters.size.split(' ');
                        shape = [0, parseInt(sizes[0], 10), parseInt(sizes[1], 10), layer.parameters.channels];
                    } else if (Object.prototype.hasOwnProperty.call(layer.parameters, 'is_scalar')) {
                        shape = [1];
                    }
                    if (shape && shape.length === 4 && shape[0] === 0) {
                        shape[0] = 1;
                    }
                }
                output.shape = shape;
                return output;
            });
            // Add other layer types (e.g., pooling, batch norm, etc.) as needed.
            if (layer.type === 'Conv2D') {
                const { kernelShape, inputShape, outputShape } = layer;
                const [kH, kW] = kernelShape;
                const [inC] = inputShape;
                const [outC, oH, oW] = outputShape;
                totalFlops += kH * kW * inC * oH * oW * outC;
            } else if (layer.type === 'Dense') {
                const { inputSize, outputSize } = layer;
                totalFlops += inputSize * outputSize;
            }
        }
        this.metrics.push(new acuity.Argument('flops', totalFlops));
        acuity.Inference.infer(model.Layers);
        for (const [name, obj] of values) {
            const type = new acuity.TensorType(null, new acuity.TensorShape(obj.shape));
            const value = new acuity.Value(name, type, null, null);
            values.set(name, value);
        }
        for (const [name, layer] of Object.entries(model.Layers)) {
            switch (layer.op.toLowerCase()) {
                case 'input': {
                    const value = values.get(layer.outputs[0].name);
                    const argument = new acuity.Argument(name, [value]);
                    this.inputs.push(argument);
                    break;
                }
                case 'output': {
                    const value = values.get(layer.inputs[0].name);
                    const argument = new acuity.Argument(name, [value]);
                    this.outputs.push(argument);
                    break;
                }
                default: {
                    const node = new acuity.Node(metadata, name, layer, values);
                    this.nodes.push(node);
                    break;
                }
            }
        }
    }
};

acuity.Node = class {

    constructor(metadata, name, layer, values) {
        const op = layer.op;
        this.name = name;
        this.type = metadata.type(op) || { name: op };
        this.inputs = [];
        this.outputs = [];
        this.attributes = [];
        if (this.type) {
            if (layer.parameters) {
                for (const [name, value] of Object.entries(layer.parameters)) {
                    const meta = metadata.attribute(op, name);
                    const type = meta && meta.type ? meta.type : null;
                    const visible = meta && meta.default !== undefined && meta.default === value ? false : true;
                    const attribute = new acuity.Argument(name, value, type, visible);
                    this.attributes.push(attribute);
                }
            }
        }
        for (let i = 0; i < layer.inputs.length; i++) {
            const input = layer.inputs[i];
            const value = values.get(input.name);
            const name = this.type && this.type.inputs && i < this.type.inputs.length ? this.type.inputs[i].name : `input${i}`;
            const argument = new acuity.Argument(name, [value]);
            this.inputs.push(argument);
        }

        if (this.type && this.type.constants) {
            for (const constant of this.type.constants) {
                // const name = "@" + this.name + ":" + constant.name;
                const type = new acuity.TensorType(null, new acuity.TensorShape(null));
                const value = new acuity.Value('', type, null, new acuity.Tensor(type));
                const argument = new acuity.Argument(constant.name, [value]);
                this.inputs.push(argument);
            }
        }

        for (let i = 0; i < layer.outputs.length; i++) {
            const output = layer.outputs[i];
            const value = values.get(output.name);
            const name = this.type && this.type.outputs && i < this.type.outputs.length ? this.type.outputs[i].name : `output${i}`;
            const argument = new acuity.Argument(name, [value]);
            this.outputs.push(argument);
        }
    }
};

acuity.Argument = class {

    constructor(name, value, type = null, visible = true) {
        this.name = name;
        this.value = value;
        this.type = type;
        this.visible = visible;
    }
};

acuity.Value = class {

    constructor(name, type = null, quantization = null, initializer = null) {
        if (typeof name !== 'string') {
            throw new acuity.Error(`Invalid value identifier '${JSON.stringify(name)}'.`);
        }
        this.name = name;
        this.type = type;
        this.quantization = quantization;
        this.initializer = initializer;
    }
};

acuity.TensorType = class {

    constructor(dataType, shape) {
        this.dataType = dataType || '?';
        this.shape = shape;
    }

    toString() {
        return (this.dataType || '?') + this.shape.toString();
    }
};

acuity.TensorShape = class {

    constructor(dimensions) {
        this.dimensions = Array.isArray(dimensions) && dimensions.length === 1 && dimensions[0] === 0 ? [] : dimensions;
    }

    toString() {
        if (!Array.isArray(this.dimensions) || this.dimensions.length === 0 || (this.dimensions.length === 1 && this.dimensions[0] === 0)) {
            return '';
        }
        return `[${this.dimensions.map((dimension) => dimension ? dimension.toString() : '?').join(',')}]`;
    }
};

acuity.Tensor = class {

    constructor(type) {
        this.type = type;
        this.Category = 'Constant';
    }
};

acuity.Inference = class {

    static infer(layers) {
        const outputs = new Map();
        const outputLayers = [];
        for (const [, layer] of Object.entries(layers)) {
            if (layer.op.toLowerCase() === 'output') {
                outputLayers.push(layer);
            }
            for (const output of layer.outputs) {
                outputs.set(output.name, layer);
            }
        }
        const broadcasts = new Set([
            'add', 'equal', 'fllor_mod', 'floor_div', 'greater', 'greater_equal', 'less', 'less_equal',
            'logical_and', 'logical_or', 'minimum', 'multiply', 'not_equal', 'pow', 'real_div',
            'squared_difference', 'subtract', 'divide', 'addn', 'Divide', 'bitwise_and', 'bitwise_or',
            'bitwise_xor', 'average', 'logical_not', 'logical_xor'
        ]);
        const passthroughs = new Set([
            'LocalResponseNormalization', 'a_times_b_plus_c', 'abs', 'batchnorm_single', 'batchnormalize',
            'cast', 'cast', 'clipbyvalue', 'dequantize', 'dtype_converter', 'elu', 'exp', 'floor',
            'groupnormalize', 'hard_sigmoid', 'hard_swish', 'instancenormalize', 'l2normalize', 'l2normalizescale',
            'layernormalize', 'leakyrelu', 'log', 'log_softmax', 'mish', 'neg', 'norm_with_channel_mean',
            'norm_with_min_max', 'norm_with_scale', 'pow', 'prelu', 'quantize', 'relu', 'relu_keras',
            'relun', 'reverse', 'round', 'rsqrt', 'sigmoid', 'sin', 'softmax', 'softrelu', 'sqrt', 'square', 'tanh',
            'swish', 'gelu', 'dropout', 'eltwise', 'cos', 'l1_layernormalize', 'inverse_sigmoid', 'selu', 'mod',
            'mish', 'minimum_with_clip', 'celu', 'cumsum', 'dft', 'dropout2', 'erf', 'noop', 'squashing', 'tan', 'ceil',
            'atan', 'atan2', 'atanh', 'alpha_dropout', 'acosh', 'rmsnormalize', 'sign'
        ]);
        const reduces = new Set([
            'reduceany', 'reducemax', 'reducemean', 'reducemin', 'reduceprod', 'reducesum'
        ]);
        const poolings = new Set([
            'pooling', 'l2pooling'
        ]);
        const operators = new Map();
        operators.set('broadcast', ([a, b]) => {
            const longer = a.length >= b.length ? a.slice() : b.slice();
            const shorter = a.length < b.length ? a.slice() : b.slice();
            const remain = longer.length - shorter.length;
            for (let i = 0; i < remain; i++) {
                shorter.splice(0, 0, 1);
            }
            for (let i = 0; i < longer.length; i++) {
                longer[i] = longer[i] > shorter[i] ? longer[i] : shorter[i];
            }
            return [longer];
        });
        operators.set('concat', (inputs, params) => {
            const outputShape = inputs[0].slice();
            outputShape[params.dim] = 0;
            for (const shape of inputs) {
                outputShape[params.dim] += shape[params.dim];
            }
            return [outputShape];
        });
        operators.set('conv1d', (inputs, params) => {
            if (params.padding === 'VALID') {
                const out_h = ~~((inputs[0][1] + params.stride - params.ksize) / params.stride);
                return [[inputs[0][0], out_h, params.weights]];
            } else if (params.padding === 'SAME') {
                const out_h = ~~((inputs[0][1] + params.stride - 1) / params.stride);
                return [[inputs[0][0], out_h, params.weights]];
            }
            return null;
        });
        operators.set('convolution', (inputs, params) => {
            if (params.padding === 'VALID') {
                const out_h = Math.floor((inputs[0][1] + params.stride_h + 2 * params.pad_h - params.ksize_h) / params.stride_h);
                const out_w = Math.floor((inputs[0][2] + params.stride_w + 2 * params.pad_w - params.ksize_w) / params.stride_w);
                return [[inputs[0][0], out_h, out_w, params.weights]];
            } else if (params.padding === 'SAME') {
                const out_h = Math.floor((inputs[0][1] + params.stride_h - 1) / params.stride_h);
                const out_w = Math.floor((inputs[0][2] + params.stride_w - 1) / params.stride_w);
                return [[inputs[0][0], out_h, out_w, params.weights]];
            }
            return null;
        });
        operators.set('depthwise_conv1d', (inputs, params) => {
            if (params.padding === 'VALID') {
                const out_h = ~~((inputs[0][1] + params.stride + params.pad[0] + params.pad[1] - params.ksize) / params.stride);
                return [[inputs[0][0], out_h, inputs[0][2] * params.multiplier]];
            } else if (params.padding === 'SAME') {
                const out_h = ~~((inputs[0][1] + params.stride - 1) / params.stride);
                return [[inputs[0][0], out_h, inputs[0][2] * params.multiplier]];
            }
            return null;
        });
        operators.set('depthwise_convolution', (inputs, params) => {
            if (params.padding === 'VALID') {
                const out_h = ~~((inputs[0][1] + params.stride_h + params.pad[0] + params.pad[1] - params.ksize_h) / params.stride_h);
                const out_w = ~~((inputs[0][2] + params.stride_w + params.pad[2] + params.pad[3] - params.ksize_w) / params.stride_w);
                return [[inputs[0][0], out_h, out_w, inputs[0][3] * params.multiplier]];
            } else if (params.padding === 'SAME') {
                const out_h = ~~((inputs[0][1] + params.stride_h - 1) / params.stride_h);
                const out_w = ~~((inputs[0][2] + params.stride_w - 1) / params.stride_w);
                return [[inputs[0][0], out_h, out_w, inputs[0][3] * params.multiplier]];
            }
            return null;
        });
        operators.set('deconvolution', (inputs, params) => {
            return [params.output_shape.map((item, index) => item === 0 ? inputs[0][index] : item)];
        });
        operators.set('deconvolution1d', (inputs, params) => {
            return [params.output_shape.map((item, index) => item === 0 ? inputs[0][index] : item)];
        });
        operators.set('fullconnect', (inputs, params) => {
            return [inputs[0].slice(0, params.axis).concat([params.weights])];
        });
        operators.set('gather', (inputs, params) => {
            const prefix = inputs[1].slice();
            const suffix = inputs[0].slice(params.axis + 1);
            return [prefix.concat(suffix)];
        });
        operators.set('lstm', (inputs, params) => {
            const [input] = inputs;
            const [a, b] = input;
            let batch = a;
            const output = params.num_proj === null ? params.weights : params.num_proj;
            if (params.time_major) {
                batch = b;
            }
            const newShape = params.return_sequences ? [a, b, output] : [batch, output];
            return [newShape, [batch, output], [batch, params.weights]];
        });
        operators.set('matmul', ([a, b], params) => {
            let newShape = a.slice(0, -2);
            if (params.transpose_a) {
                newShape = newShape.concat(a.slice(-1));
            } else {
                newShape = newShape.concat(a.slice(-2, -1));
            }
            if (params.transpose_b) {
                newShape = newShape.concat(b.slice(-2, -1));
            } else {
                newShape = newShape.concat(b.slice(-1));
            }
            return [newShape];
        });
        operators.set('pad', (inputs, params) => {
            return [inputs[0].map((item, index) => item + params.padding_value[index][0] + params.padding_value[index][1])];
        });
        operators.set('permute', (inputs, params) => {
            return [inputs[0].map((item, index) => inputs[0][params.perm[index]])];
        });
        operators.set('pooling', (inputs, params) => {
            if (params.padding === 'VALID') {
                const out_h = ~~((inputs[0][1] + params.stride_h - params.ksize_h) / params.stride_h);
                const out_w = ~~((inputs[0][2] + params.stride_w - params.ksize_w) / params.stride_w);
                return [[inputs[0][0], out_h, out_w, inputs[0][3]]];
            } else if (params.padding === 'SAME') {
                const out_h = ~~((inputs[0][1] + params.stride_h - 1) / params.stride_h);
                const out_w = ~~((inputs[0][2] + params.stride_w - 1) / params.stride_w);
                return [[inputs[0][0], out_h, out_w, inputs[0][3]]];
            }
            return null;
        });
        operators.set('reduce', (inputs, params) => {
            const newShape = inputs[0].slice();
            const axis_list = params.axis_list.map((item) => {
                return item < 0 ? newShape.length + item : item;
            });
            axis_list.sort((a, b) => {
                return b - a;
            });
            axis_list.forEach((i) => {
                newShape[i] = 1;
            });
            if (!params.keep_dims) {
                axis_list.forEach((i) => {
                    newShape.splice(i, 1);
                });
                if (!newShape.length) {
                    newShape.splice(0, 0, 0);
                }
            }
            return [newShape];
        });
        operators.set('repeat', (inputs, params) => {
            const newShape = inputs[0].slice();
            newShape[params.axis] = params.maxlen;
            return [newShape];
        });
        operators.set('reshape', (inputs, params) => {
            const negativeIndexs = [];
            let shape = params.shape;
            if (typeof params.shape === 'string') {
                shape = params.shape.split(/\s+/).map((item) => {
                    return parseInt(item, 10);
                });
            }
            const newShape = shape.map((item, index) => {
                if (item === 0) {
                    return inputs[0][index];
                }
                if (item === -1) {
                    negativeIndexs.push(index);
                    return 1;
                }
                return item;
            });
            if (negativeIndexs.length > 0) {
                newShape[negativeIndexs[0]] = inputs[0].reduce((a, c) => a * c) / newShape.reduce((a, c) => a * c);
            }
            return [newShape];
        });
        operators.set('sequence_mask', (inputs, params) => {
            return [inputs[0].slice().concat([params.maxlen])];
        });
        operators.set('slice', (inputs, params) => {
            return [params.size.map((item, index) => item === -1 ? inputs[0][index] : item)];
        });
        operators.set('squeeze', (inputs, params) => {
            const newShape = inputs[0].slice();
            const axis_list = [...new Set(params.axis_list)].sort((a, b) => b - a);
            for (const item of axis_list) {
                newShape.splice(item, 1);
            }
            return [newShape];
        });
        operators.set('space2depth', (inputs, params) => {
            const h = inputs[0][1] / params.block_size[0];
            const w = inputs[0][2] / params.block_size[1];
            const c = inputs[0][3] * params.block_size[1] * params.block_size[1];
            return [[inputs[0][0], h, w, c]];
        });
        operators.set('depth2space', (inputs, params) => {
            const h = inputs[0][1] * params.block_size;
            const w = inputs[0][2] * params.block_size;
            const c = inputs[0][3] / (params.block_size * params.block_size);
            return [[inputs[0][0], h, w, c]];
        });
        operators.set('upsampling', (inputs, params) => {
            const h = inputs[0][1] * params.factor;
            const w = inputs[0][2] * params.factor;
            return [[inputs[0][0], h, w, inputs[0][3]]];
        });
        operators.set('crop_image', (inputs, params) => {
            return [[inputs[0][0], params.crop_size[0], params.crop_size[1], inputs[0][3]]];
        });
        operators.set('split', (inputs, params) => {
            const sizes = [];
            const slices = params.slices.slice();
            slices.splice(0, 0, 0);
            slices.push(inputs[0][params.dim]);
            slices.reduce((a, b) => {
                sizes.push(b - a);
                return b;
            });
            return sizes.map((item) => {
                const shape = inputs[0].slice();
                shape[params.dim] = item;
                return shape;
            });
        });
        operators.set('stack', (inputs, params) => {
            const newShape = inputs[0].slice();
            if (newShape.length === 1 && newShape[0] === 0) {
                newShape[0] = 1;
            } else {
                newShape.splice(params.axis, 0, inputs.length);
            }
            return [newShape];
        });
        operators.set('stridedslice', (inputs, params) => {
            const input_shape = inputs[0].slice();
            const begin = params.slice_begin.slice();
            const end = params.slice_end.slice();
            if (params.slice_begin_mask > 0) {
                for (let i = 0; i < begin.length; i++) {
                    if ((params.slice_begin_mask >>> i) & 0x1) {
                        begin[i] = -1;
                    }
                }
            }
            if (params.slice_end_mask > 0) {
                for (let i = 0; i < end.length; i++) {
                    if ((params.slice_end_mask >>> i) & 0x1) {
                        end[i] = -1;
                    }
                }
            }
            for (let i = 0; i < begin.length; i++) {
                if (begin[i] === -1) {
                    begin[i] = 0;
                }
            }
            if (inputs[0].length === end.length) {
                for (let i = 0; i < end.length; i++) {
                    if (end[i] === -1 || end[i] > input_shape[i]) {
                        end[i] = input_shape[i];
                    }
                }
            } else if (inputs[0].length < end.length) {
                if (params.slice_new_axis_mask) {
                    const len = (params.slice_new_axis_mask >>> 0).toString(2).length;
                    for (let i = 0; i < len; i++) {
                        if ((params.slice_new_axis_mask >>> i) & 0x1) {
                            input_shape.splice(i, 0, 1);
                        }
                    }
                    for (let i = 0; i < end.length; i++) {
                        if (end[i] === -1) {
                            end[i] = input_shape[i];
                        }
                    }
                }
            }
            let newShape = [];
            for (let i = 0; i < begin.length; i++) {
                newShape = newShape.concat([(end[i] - begin[i]) / params.slice_strides[i]]);
            }
            if (params.slice_shrink_axis_mask) {
                const len = (params.slice_shrink_axis_mask >>> 0).toString(2).length;
                for (let i = 0; i < len; i++) {
                    if ((params.slice_shrink_axis_mask >>> i) & 0x1) {
                        newShape.splice(i, 1);
                    }
                }
            }
            if (params.slice_new_axis_mask) {
                const len = (params.slice_new_axis_mask >>> 0).toString(2).length;
                for (let i = 0; i < len; i++) {
                    if ((params.slice_new_axis_mask >>> i) & 0x1) {
                        if (inputs[0].length === begin.length) {
                            newShape.splice(i, 0, 1);
                        } else if (inputs[0].length < begin.length) {
                            newShape[i] = 1;
                        }
                    }
                }
            }
            return [newShape];
        });
        operators.set('image_resize', (inputs, params) => {
            const newShape = inputs[0].slice();
            newShape[1] = params.new_size[0];
            newShape[2] = params.new_size[1];
            return [newShape];
        });
        operators.set('argmax', (inputs, params) => {
            const newShape = inputs[0].slice();
            if (params.keepdims) {
                newShape[params.axis] = 1;
            } else {
                newShape.splice(params.axis, 1);
                if (!newShape.length) {
                    newShape.splice(0, 0, 0);
                }
            }
            return [newShape];
        });
        operators.set('argmin', operators.get('argmax'));
        /* eslint-disable no-unused-vars */
        operators.set('shapelayer', (inputs, params) => {
            return [[inputs[0].length]];
        });
        operators.set('capsule_norm', (inputs, params) => {
            return [[inputs[0][0], inputs[0][inputs[0].length - 1]]];
        });
        operators.set('size', (inputs, params) => {
            return [[1]];
        });
        /* eslint-enable no-unused-vars */
        operators.set('einsum', ((operators, inputs, params) => {
            const identifyOperation = (inputs, equation) => {
                const identifyFuncs = new Map();
                identifyFuncs.set('matmul', (inputs, equation) => {
                    if (inputs.length !== 2) {
                        return { found: false };
                    }

                    const parts = equation.replace(/\s+/g, '').split(/,|->/);
                    if (parts.length !== 3) {
                        return { found: false };
                    }

                    const [first, second, output] = parts.map((p) => p.split(''));
                    if (!(first.length === output.length || second.length === output.length)) {
                        return { found: false };
                    }

                    let a = first.slice(-2);
                    const b = second.slice(-2);
                    const c = output.slice(-2);
                    let transpose_a = false;
                    let transpose_b = false;
                    if (a[0] === c[0]) {
                        transpose_a = false;
                    } else if (a[1] === c[0]) {
                        transpose_a = true;
                        a = [].concat(a.reverse());
                    } else {
                        return { found: false };
                    }

                    if (a[1] === b[0]) {
                        transpose_b = false;
                    } else if (a[1] === b[1]) {
                        transpose_b = true;
                    } else {
                        return { found: false };
                    }
                    return { found: true, op: 'matmul', params: { transpose_a, transpose_b } };
                });

                /* eslint-disable no-unused-vars */
                for (const [name, func] of identifyFuncs.entries()) {
                    const result = func(inputs, equation);
                    if (result.found) {
                        return result;
                    }
                }
                /* eslint-enable no-unused-vars */
                return { found: false };
            };

            const result = identifyOperation(inputs, params.equation);
            if (result.found) {
                if (operators.has(result.op)) {
                    return operators.get(result.op)(inputs, result.params);
                }
            }
            return [];
        }).bind(undefined, operators));
        const infer = (output) => {
            if (outputs.has(output.name)) {
                let ready = true;
                const layer = outputs.get(output.name);
                for (const input of layer.inputs) {
                    if (input.shape === null) {
                        infer(input);
                        if (input.shape === null) {
                            ready = false;
                            break;
                        }
                    }
                }
                if (ready) {
                    let callback = null;
                    if (operators.has(layer.op)) {
                        callback = operators.get(layer.op);
                    } else if (passthroughs.has(layer.op)) {
                        callback = (inputs) => [inputs[0].slice()];
                    } else if (broadcasts.has(layer.op)) {
                        callback = operators.get('broadcast');
                    } else if (reduces.has(layer.op)) {
                        callback = operators.get('reduce');
                    } else if (poolings.has(layer.op)) {
                        callback = operators.get('pooling');
                    }
                    if (!callback) {
                        callback = () => [];
                    }
                    const parameters = layer.parameters;
                    const inputs = layer.inputs.map((input) => input.shape);
                    const outputs = callback(inputs, parameters);
                    for (let i = 0; i < outputs.length; i++) {
                        if (i < layer.outputs.length) {
                            layer.outputs[i].shape = outputs[i];
                        }
                    }
                }
            }
        };
        for (const layer of outputLayers) {
            for (const output of layer.outputs) {
                infer(output);
            }
        }
    }
};

acuity.Error = class extends Error {

    constructor(message) {
        super(message);
        this.name = 'Error loading Acuity model.';
    }
};

export const ModelFactory = acuity.ModelFactory;

================================================
FILE: source/app.js
================================================

import * as base from './base.js';
import * as electron from 'electron';
import * as fs from 'fs';
import * as os from 'os';
import * as path from 'path';
import * as process from 'process';
import * as updater from 'electron-updater';
import * as url from 'url';

const app = {};

app.Application = class {

    constructor() {
        this._views = new app.ViewCollection(this);
        this._configuration = new app.ConfigurationService();
        this._menu = new app.MenuService(this._views);
        this._openQueue = [];
        this._package = {};
    }

    async start() {
        const dirname = path.dirname(url.fileURLToPath(import.meta.url));
        const packageFile = path.join(path.dirname(dirname), 'package.json');
        const packageContent =  fs.readFileSync(packageFile, 'utf-8');
        this._package = JSON.parse(packageContent);

        electron.app.setAppUserModelId('com.lutzroeder.netron');
        electron.app.allowRendererProcessReuse = true;

        if (!electron.app.requestSingleInstanceLock()) {
            electron.app.quit();
            return;
        }

        electron.app.on('second-instance', (event, commandLine, workingDirectory) => {
            const currentDirectory = process.cwd();
            process.chdir(workingDirectory);
            const open = this._parseCommandLine(commandLine);
            process.chdir(currentDirectory);
            if (!open && !this._views.empty) {
                const view = this._views.first();
                if (view) {
                    view.restore();
                }
            }
        });
        electron.ipcMain.on('get-environment', (event) => {
            event.returnValue = this.environment;
        });
        electron.ipcMain.on('get-configuration', (event, obj) => {
            event.returnValue = this._configuration.has(obj.name) ? this._configuration.get(obj.name) : undefined;
        });
        electron.ipcMain.on('set-configuration', (event, obj) => {
            this._configuration.set(obj.name, obj.value);
            this._configuration.save();
            event.returnValue = null;
        });
        electron.ipcMain.on('delete-configuration', (event, obj) => {
            this._configuration.delete(obj.name);
            this._configuration.save();
            event.returnValue = null;
        });
        electron.ipcMain.on('drop-paths', (event, data) => {
            const paths = data.paths.filter((path) => {
                if (fs.existsSync(path)) {
                    const stat = fs.statSync(path);
                    return stat.isFile() || stat.isDirectory();
                }
                return false;
            });
            this._dropPaths(event.sender, paths);
            event.returnValue = null;
        });
        electron.ipcMain.on('update-recents', (event, data) => {
            this._updateRecents(data.path);
            event.returnValue = null;
        });
        electron.ipcMain.on('show-save-dialog', async (event, options) => {
            const owner = event.sender.getOwnerBrowserWindow();
            const argument = {};
            try {
                const { filePath, canceled } = await electron.dialog.showSaveDialog(owner, options);
                argument.filePath = filePath;
                argument.canceled = canceled;
            } catch (error) {
                argument.error = error.message;
            }
            event.sender.send('show-save-dialog-complete', argument);
        });
        electron.ipcMain.on('execute', async (event, data) => {
            const owner = event.sender.getOwnerBrowserWindow();
            const argument = {};
            try {
                argument.value = await this.execute(data.name, data.value || null, owner);
            } catch (error) {
                argument.error = error.message;
            }
            event.sender.send('execute-complete', argument);
        });

        electron.app.on('will-finish-launching', () => {
            electron.app.on('open-file', (event, path) => {
                this._openPath(path);
            });
        });

        electron.app.on('ready', () => {
            this._ready();
        });

        electron.app.on('window-all-closed', () => {
            if (process.platform !== 'darwin') {
                electron.app.quit();
            }
        });

        electron.app.on('will-quit', () => {
            this._configuration.save();
        });

        this._parseCommandLine(process.argv);
        await this._checkForUpdates();
    }

    get environment() {
        this._environment = this._environment || {
            packaged: electron.app.isPackaged,
            name: this._package.productName,
            version: this._package.version,
            date: this._package.date,
            repository: `https://github.com/${this._package.repository}`,
            platform: process.platform,
            separator: path.sep,
            titlebar: true // process.platform === 'darwin'
        };
        return this._environment;
    }

    _parseCommandLine(argv) {
        let open = false;
        if (argv.length > 1) {
            for (const arg of argv.slice(1)) {
                const dirname = path.dirname(url.fileURLToPath(import.meta.url));
                if (!arg.startsWith('-') && arg !== path.dirname(dirname)) {
                    const extension = path.extname(arg).toLowerCase();
                    if (extension !== '' && extension !== '.js' && fs.existsSync(arg)) {
                        const stat = fs.statSync(arg);
                        if (stat.isFile() || stat.isDirectory()) {
                            this._openPath(arg);
                            open = true;
                        }
                    }
                }
            }
        }
        return open;
    }

    _ready() {
        this._configuration.open();
        if (this._openQueue) {
            const queue = this._openQueue;
            this._openQueue = null;
            while (queue.length > 0) {
                const file = queue.shift();
                this._openPath(file);
            }
        }
        if (this._views.empty) {
            this._views.openView();
        }
        this._updateMenu();
        this._views.on('active-view-changed', () => {
            this._menu.update();
        });
        this._views.on('active-view-updated', () => {
            this._menu.update();
        });
    }

    _open(path) {
        let paths = path ? [path] : [];
        if (paths.length === 0) {
            const extensions = new base.Metadata().extensions;
            const options = {
                properties: ['openFile'],
                filters: [{ name: 'All Model Files', extensions }]
            };
            const owner = electron.BrowserWindow.getFocusedWindow();
            paths = electron.dialog.showOpenDialogSync(owner, options);
        }
        if (Array.isArray(paths) && paths.length > 0) {
            for (const path of paths) {
                this._openPath(path);
            }
        }
    }

    _openPath(path) {
        if (this._openQueue) {
            this._openQueue.push(path);
            return;
        }
        if (path && path.length > 0) {
            const exists = fs.existsSync(path);
            if (exists) {
                const stat = fs.statSync(path);
                if (stat.isFile() || stat.isDirectory()) {
                    const views = Array.from(this._views.views);
                    // find existing view for this file
                    let view = views.find((view) => view.match(path));
                    // find empty welcome window
                    if (!view) {
                        view = views.find((view) => view.match(null));
                    }
                    // create new window
                    if (!view) {
                        view = this._views.openView();
                    }
                    view.open(path);
                }
            }
            this._updateRecents(exists ? path : undefined);
        }
    }

    _dropPaths(sender, paths) {
        const window = sender.getOwnerBrowserWindow();
        let view = this._views.get(window);
        for (const path of paths) {
            if (view) {
                view.open(path);
                view = null;
            } else {
                this._openPath(path);
            }
        }
    }

    async _export() {
        const view = this._views.activeView;
        if (view && view.path) {
            let defaultPath = 'Untitled';
            const file = view.path;
            const lastIndex = file.lastIndexOf('.');
            if (lastIndex !== -1) {
                defaultPath = file.substring(0, lastIndex);
            }
            const owner = electron.BrowserWindow.getFocusedWindow();
            const options = {
                title: 'Export',
                defaultPath,
                buttonLabel: 'Export',
                filters: [
                    { name: 'PNG', extensions: ['png'] },
                    { name: 'SVG', extensions: ['svg'] }
                ]
            };
            const { filePath, canceled } = await electron.dialog.showSaveDialog(owner, options);
            if (filePath && !canceled) {
                view.execute('export', { 'file': filePath });
            }
        }
    }

    async execute(command, value, window) {
        switch (command) {
            case 'open': this._open(value); break;
            case 'export': await this._export(); break;
            case 'close': window.close(); break;
            case 'quit': electron.app.quit(); break;
            case 'reload': this._reload(); break;
            case 'report-issue': electron.shell.openExternal(`https://github.com/${this._package.repository}/issues/new`); break;
            case 'about': this._about(); break;
            default: {
                const view = this._views.get(window) || this._views.activeView;
                if (view && view.get(`${command}.enabled`) !== false) {
                    view.execute(command, value || {});
                }
                this._menu.update();
            }
        }
    }

    _reload() {
        const view = this._views.activeView;
        if (view && view.path) {
            view.open(view.path);
        }
    }

    async _checkForUpdates() {
        if (!electron.app.isPackaged) {
            return;
        }
        const autoUpdater = updater.default.autoUpdater;
        if (autoUpdater.app && autoUpdater.app.appUpdateConfigPath && !fs.existsSync(autoUpdater.app.appUpdateConfigPath)) {
            return;
        }
        const promise = autoUpdater.checkForUpdates();
        if (promise) {
            promise.catch((error) => {
                /* eslint-disable no-console */
                console.log(error.message);
                /* eslint-enable no-console */
            });
        }
    }

    _about() {
        let view = this._views.activeView;
        if (!view) {
            view = this._views.openView();
        }
        view.execute('about');
    }

    _updateRecents(path) {
        let updated = false;
        let recents = this._configuration.has('recents') ? this._configuration.get('recents') : [];
        if (path && (recents.length === 0 || recents[0] !== path)) {
            recents = recents.filter((recent) => path !== recent);
            recents.unshift(path);
            updated = true;
        }
        const value = [];
        for (const recent of recents) {
            if (value.length >= 9) {
                updated = true;
                break;
            }
            if (!fs.existsSync(recent)) {
                updated = true;
                continue;
            }
            const stat = fs.statSync(recent);
            if (!stat.isFile() && !stat.isDirectory()) {
                updated = true;
                continue;
            }
            value.push(recent);
        }
        if (updated) {
            this._configuration.set('recents', value);
            this._updateMenu();
        }
    }

    _updateMenu() {

        let recents = [];
        if (this._configuration.has('recents')) {
            const value = this._configuration.get('recents');
            recents = value.map((recent) => app.Application.location(recent));
        }

        if (this.environment.titlebar && recents.length > 0) {
            for (const view of this._views.views) {
                view.execute('recents', recents);
            }
        }

        const darwin = process.platform === 'darwin';
        if (!this.environment.titlebar || darwin) {
            const menuRecentsTemplate = [];
            for (let i = 0; i < recents.length; i++) {
                const recent = recents[i];
                menuRecentsTemplate.push({
                    path: recent.path,
                    label: recent.label,
                    accelerator: (darwin ? 'Cmd+' : 'Ctrl+') + (i + 1).toString(),
                    click: (item) => this._openPath(item.path)
                });
            }

            const menuTemplate = [];

            if (darwin) {
                menuTemplate.unshift({
                    label: electron.app.name,
                    submenu: [
                        {
                            label: `About ${electron.app.name}`,
                            click: () => /* this.execute('about', null) */ this._about()
                        },
                        { type: 'separator' },
                        { role: 'hide' },
                        { role: 'hideothers' },
                        { role: 'unhide' },
                        { type: 'separator' },
                        { role: 'quit' }
                    ]
                });
            }

            const fileSubmenu = [
                {
                    label: '&Open...',
                    accelerator: 'CmdOrCtrl+O',
                    click: () => this._open(null)
                },
                {
                    label: 'Open &Recent',
                    submenu: menuRecentsTemplate
                },
                { type: 'separator' },
                {
                    id: 'file.export',
                    label: '&Export...',
                    accelerator: 'CmdOrCtrl+Shift+E',
                    click: async () => await this.execute('export', null)
                },
                { type: 'separator' },
                { role: 'close' },
            ];

            if (!darwin) {
                fileSubmenu.push(
                    { type: 'separator' },
                    { role: 'quit' }
                );
            }

            menuTemplate.push({
                label: '&File',
                submenu: fileSubmenu
            });

            if (darwin) {
                electron.systemPreferences.setUserDefault('NSDisabledDictationMenuItem', 'boolean', true);
                electron.systemPreferences.setUserDefault('NSDisabledCharacterPaletteMenuItem', 'boolean', true);
            }

            menuTemplate.push({
                label: '&Edit',
                submenu: [
                    {
                        id: 'edit.cut',
                        label: 'Cu&t',
                        accelerator: 'CmdOrCtrl+X',
                        click: async () => await this.execute('cut', null),
                    },
                    {
                        id: 'edit.copy',
                        label: '&Copy',
                        accelerator: 'CmdOrCtrl+C',
                        click: async () => await this.execute('copy', null),
                    },
                    {
                        id: 'edit.paste',
                        label: '&Paste',
                        accelerator: 'CmdOrCtrl+V',
                        click: async () => await this.execute('paste', null),
                    },
                    {
                        id: 'edit.select-all',
                        label: 'Select &All',
                        accelerator: 'CmdOrCtrl+A',
                        click: async () => await this.execute('selectall', null),
                    },
                    { type: 'separator' },
                    {
                        id: 'edit.find',
                        label: '&Find...',
                        accelerator: 'CmdOrCtrl+F',
                        click: async () => await this.execute('find', null),
                    }
                ]
            });

            const viewTemplate = {
                label: '&View',
                submenu: [
                    {
                        id: 'view.toggle-attributes',
                        accelerator: 'CmdOrCtrl+D',
                        click: async () => await this.execute('toggle', 'attributes'),
                    },
                    {
                        id: 'view.toggle-weights',
                        accelerator: 'CmdOrCtrl+I',
                        click: async () => await this.execute('toggle', 'weights'),
                    },
                    {
                        id: 'view.toggle-names',
                        accelerator: 'CmdOrCtrl+U',
                        click: async () => await this.execute('toggle', 'names'),
                    },
                    {
                        id: 'view.toggle-direction',
                        accelerator: 'CmdOrCtrl+K',
                        click: async () => await this.execute('toggle', 'direction')
                    },
                    {
                        id: 'view.toggle-mousewheel',
                        accelerator: 'CmdOrCtrl+M',
                        click: async () => await this.execute('toggle', 'mousewheel'),
                    },
                    { type: 'separator' },
                    {
                        id: 'view.reload',
                        label: '&Reload',
                        accelerator: darwin ? 'Cmd+R' : 'F5',
                        click: async () => await this._reload(),
                    },
                    { type: 'separator' },
                    {
                        id: 'view.zoom-reset',
                        label: 'Actual &Size',
                        accelerator: 'Shift+Backspace',
                        click: async () => await this.execute('zoom-reset', null),
                    },

Download .txt

gitextract__jg6eqyf/

├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   └── feature_request.md
│   └── workflows/
│       ├── build.yml
│       └── publish.yml
├── .gitignore
├── .npmrc
├── .vscode/
│   ├── launch.json
│   └── settings.json
├── CITATION.cff
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── eslint.config.js
├── package.js
├── package.json
├── package.py
├── publish/
│   ├── electron-builder.json
│   ├── icon.html
│   └── icon.icns
├── pyproject.toml
├── source/
│   ├── __init__.py
│   ├── acuity-metadata.json
│   ├── acuity.js
│   ├── app.js
│   ├── armnn-metadata.json
│   ├── armnn-schema.js
│   ├── armnn.js
│   ├── barracuda.js
│   ├── base.js
│   ├── bigdl-metadata.json
│   ├── bigdl-proto.js
│   ├── bigdl.js
│   ├── browser.js
│   ├── caffe-metadata.json
│   ├── caffe-proto.js
│   ├── caffe.js
│   ├── caffe2-metadata.json
│   ├── caffe2-proto.js
│   ├── caffe2.js
│   ├── catboost-schema.js
│   ├── catboost.js
│   ├── circle-metadata.json
│   ├── circle-schema.js
│   ├── circle.js
│   ├── cntk-metadata.json
│   ├── cntk-proto.js
│   ├── cntk.js
│   ├── coreml-metadata.json
│   ├── coreml-proto.js
│   ├── coreml.js
│   ├── dagre.js
│   ├── darknet-metadata.json
│   ├── darknet.js
│   ├── desktop.mjs
│   ├── dl4j-metadata.json
│   ├── dl4j.js
│   ├── dlc-metadata.json
│   ├── dlc-schema.js
│   ├── dlc.js
│   ├── dnn-metadata.json
│   ├── dnn-proto.js
│   ├── dnn.js
│   ├── dot.js
│   ├── espdl-metadata.json
│   ├── espdl-schema.js
│   ├── espdl.js
│   ├── espresso-metadata.json
│   ├── espresso.js
│   ├── executorch-schema.js
│   ├── executorch.js
│   ├── flatbuffers.js
│   ├── flax.js
│   ├── flexbuffers.js
│   ├── flux-metadata.json
│   ├── flux.js
│   ├── gguf-metadata.json
│   ├── gguf.js
│   ├── grapher.css
│   ├── grapher.js
│   ├── hailo-metadata.json
│   ├── hailo.js
│   ├── hdf5.js
│   ├── hickle.js
│   ├── imgdnn.js
│   ├── index.html
│   ├── index.js
│   ├── json.js
│   ├── kann-metadata.json
│   ├── kann-schema.js
│   ├── kann.js
│   ├── keras-metadata.json
│   ├── keras-proto.js
│   ├── keras.js
│   ├── kmodel.js
│   ├── lasagne-metadata.json
│   ├── lasagne.js
│   ├── lightgbm.js
│   ├── mediapipe.js
│   ├── megengine-metadata.json
│   ├── megengine-schema.js
│   ├── megengine.js
│   ├── message.js
│   ├── mlir-metadata.json
│   ├── mlir.js
│   ├── mlnet-metadata.json
│   ├── mlnet.js
│   ├── mnn-metadata.json
│   ├── mnn-schema.js
│   ├── mnn.js
│   ├── mslite-metadata.json
│   ├── mslite-schema.js
│   ├── mslite.js
│   ├── mxnet-metadata.json
│   ├── mxnet.js
│   ├── ncnn-metadata.json
│   ├── ncnn.js
│   ├── nnabla-metadata.json
│   ├── nnabla-proto.js
│   ├── nnabla.js
│   ├── nnc.js
│   ├── nnef.js
│   ├── node.js
│   ├── numpy.js
│   ├── om-metadata.json
│   ├── om-proto.js
│   ├── om.js
│   ├── onednn-metadata.json
│   ├── onednn.js
│   ├── onnx-metadata.json
│   ├── onnx-proto.js
│   ├── onnx-schema.js
│   ├── onnx.js
│   ├── onnx.py
│   ├── openvino-metadata.json
│   ├── openvino.js
│   ├── paddle-metadata.json
│   ├── paddle-proto.js
│   ├── paddle-schema.js
│   ├── paddle.js
│   ├── pickle.js
│   ├── protobuf.js
│   ├── python.js
│   ├── pytorch-metadata.json
│   ├── pytorch-proto.js
│   ├── pytorch-schema.js
│   ├── pytorch.js
│   ├── pytorch.py
│   ├── qnn-metadata.json
│   ├── qnn.js
│   ├── rknn-metadata.json
│   ├── rknn-schema.js
│   ├── rknn.js
│   ├── safetensors.js
│   ├── sentencepiece-proto.js
│   ├── sentencepiece.js
│   ├── server.py
│   ├── sklearn-metadata.json
│   ├── sklearn.js
│   ├── tar.js
│   ├── tengine-metadata.json
│   ├── tengine.js
│   ├── tensorrt.js
│   ├── text.js
│   ├── tf-metadata.json
│   ├── tf-proto.js
│   ├── tf.js
│   ├── tflite-metadata.json
│   ├── tflite-schema.js
│   ├── tflite.js
│   ├── tnn-metadata.json
│   ├── tnn.js
│   ├── torch-metadata.json
│   ├── torch.js
│   ├── tosa-metadata.json
│   ├── tosa-schema.js
│   ├── tosa.js
│   ├── transformers.js
│   ├── tvm.js
│   ├── uff-metadata.json
│   ├── uff-proto.js
│   ├── uff.js
│   ├── view.js
│   ├── weka.js
│   ├── worker.js
│   ├── xgboost.js
│   ├── xml.js
│   ├── xmodel-proto.js
│   ├── xmodel.js
│   └── zip.js
├── test/
│   ├── backend.py
│   ├── browser.spec.js
│   ├── desktop.spec.js
│   ├── measures.py
│   ├── mock.js
│   ├── models.js
│   ├── models.json
│   ├── playwright.config.js
│   ├── playwright.reporter.js
│   └── worker.js
└── tools/
    ├── armnn
    ├── bigdl
    ├── caffe
    ├── caffe-script.js
    ├── catboost
    ├── circle
    ├── circle-script.js
    ├── cntk
    ├── coreml
    ├── dlc
    ├── dlc.fbs
    ├── dnn
    ├── dnn.proto
    ├── espdl
    ├── espdl-script.js
    ├── executorch
    ├── flatc.js
    ├── gguf
    ├── kann
    ├── keras
    ├── keras_script.py
    ├── mediapipe
    ├── megengine
    ├── megengine-script.js
    ├── mlir
    ├── mlir-script.js
    ├── mnn
    ├── mslite
    ├── mslite-script.js
    ├── nnabla
    ├── nnabla_script.py
    ├── om
    ├── om.proto
    ├── onnx
    ├── onnx_script.py
    ├── paddle
    ├── protoc.js
    ├── pytorch
    ├── pytorch_script.py
    ├── rknn
    ├── rknn.fbs
    ├── sentencepiece
    ├── sklearn
    ├── sklearn_script.py
    ├── tablegen.js
    ├── tf
    ├── tf_script.py
    ├── tflite-script.js
    ├── tosa
    ├── tosa-script.js
    ├── uff
    ├── uff.proto
    └── xmodel

Download .txt

Showing preview only (410K chars total). Download the full file or copy to clipboard to get everything.

SYMBOL INDEX (6485 symbols across 82 files)

FILE: package.js
  method start (line 118) | start(controller) {

FILE: package.py
  function _build (line 10) | def _build():
  function _install (line 22) | def _install():
  function _version (line 26) | def _version():
  function _start (line 50) | def _start():
  function main (line 56) | def main():

FILE: source/__init__.py
  function main (line 12) | def main():

FILE: source/acuity.js
  method match (line 6) | async match(context) {
  method open (line 14) | async open(context) {
  method constructor (line 22) | constructor(metadata, model, data, quantization) {
  method constructor (line 32) | constructor(metadata, model) {
  method constructor (line 114) | constructor(metadata, name, layer, values) {
  method constructor (line 162) | constructor(name, value, type = null, visible = true) {
  method constructor (line 172) | constructor(name, type = null, quantization = null, initializer = null) {
  method constructor (line 185) | constructor(dataType, shape) {
  method toString (line 190) | toString() {
  method constructor (line 197) | constructor(dimensions) {
  method toString (line 201) | toString() {
  method constructor (line 211) | constructor(type) {
  method infer (line 219) | static infer(layers) {
  method constructor (line 693) | constructor(message) {

FILE: source/app.js
  method constructor (line 15) | constructor() {
  method start (line 23) | async start() {
  method environment (line 127) | get environment() {
  method _parseCommandLine (line 141) | _parseCommandLine(argv) {
  method _ready (line 161) | _ready() {
  method _open (line 183) | _open(path) {
  method _openPath (line 201) | _openPath(path) {
  method _dropPaths (line 229) | _dropPaths(sender, paths) {
  method _export (line 242) | async _export() {
  method execute (line 268) | async execute(command, value, window) {
  method _reload (line 287) | _reload() {
  method _checkForUpdates (line 294) | async _checkForUpdates() {
  method _about (line 312) | _about() {
  method _updateRecents (line 320) | _updateRecents(path) {
  method _updateMenu (line 351) | _updateMenu() {
  method location (line 634) | static location(path) {
  method constructor (line 647) | constructor(owner) {
  method window (line 722) | get window() {
  method path (line 726) | get path() {
  method open (line 730) | async open(path) {
  method restore (line 750) | restore() {
  method match (line 759) | match(path) {
  method execute (line 766) | execute(command, data) {
  method update (line 790) | update(data) {
  method get (line 812) | get(name) {
  method on (line 816) | on(event, callback) {
  method emit (line 822) | emit(event, data) {
  method state (line 830) | state(event) {
  method constructor (line 854) | constructor(application) {
  method application (line 895) | get application() {
  method views (line 899) | get views() {
  method empty (line 903) | get empty() {
  method get (line 907) | get(window) {
  method openView (line 911) | openView() {
  method closeView (line 929) | closeView(view) {
  method first (line 934) | first() {
  method activeView (line 938) | get activeView() {
  method on (line 942) | on(event, callback) {
  method emit (line 948) | emit(event, data) {
  method _updateActiveView (line 956) | _updateActiveView() {
  method constructor (line 968) | constructor() {
  method open (line 976) | open() {
  method save (line 993) | save() {
  method has (line 1000) | has(name) {
  method set (line 1004) | set(name, value) {
  method get (line 1008) | get(name) {
  method delete (line 1012) | delete(name) {
  method constructor (line 1019) | constructor(views) {
  method build (line 1023) | build(menuTemplate, commandTable) {
  method update (line 1040) | update() {
  method _rebuild (line 1051) | _rebuild() {
  method _updateLabel (line 1063) | _updateLabel(view) {
  method _updateEnabled (line 1082) | _updateEnabled(view) {

FILE: source/armnn-schema.js
  method decode (line 69) | static decode(reader, position) {
  method decodeText (line 83) | static decodeText(reader, json) {
  method decode (line 100) | static decode(reader, position) {
  method decodeText (line 107) | static decodeText(reader, json) {
  method decode (line 117) | static decode(reader, position) {
  method decodeText (line 123) | static decodeText(reader, json) {
  method decode (line 132) | static decode(reader, position) {
  method decodeText (line 138) | static decodeText(reader, json) {
  method decode (line 147) | static decode(reader, position) {
  method decodeText (line 153) | static decodeText(reader, json) {
  method decode (line 162) | static decode(reader, position) {
  method decodeText (line 168) | static decodeText(reader, json) {
  method decode (line 177) | static decode(reader, position, type) {
  method decodeText (line 187) | static decodeText(reader, json, type) {
  method decode (line 200) | static decode(reader, position) {
  method decodeText (line 207) | static decodeText(reader, json) {
  method decode (line 217) | static decode(reader, position) {
  method decodeText (line 226) | static decodeText(reader, json) {
  method decode (line 238) | static decode(reader, position) {
  method decodeText (line 245) | static decodeText(reader, json) {
  method decode (line 331) | static decode(reader, position) {
  method decodeText (line 341) | static decodeText(reader, json) {
  method decode (line 354) | static decode(reader, position) {
  method decodeText (line 361) | static decodeText(reader, json) {
  method decode (line 371) | static decode(reader, position) {
  method decodeText (line 377) | static decodeText(reader, json) {
  method decode (line 386) | static decode(reader, position) {
  method decodeText (line 393) | static decodeText(reader, json) {
  method decode (line 403) | static decode(reader, position) {
  method decodeText (line 411) | static decodeText(reader, json) {
  method decode (line 422) | static decode(reader, position) {
  method decodeText (line 428) | static decodeText(reader, json) {
  method decode (line 437) | static decode(reader, position) {
  method decodeText (line 444) | static decodeText(reader, json) {
  method decode (line 454) | static decode(reader, position) {
  method decodeText (line 461) | static decodeText(reader, json) {
  method decode (line 471) | static decode(reader, position) {
  method decodeText (line 477) | static decodeText(reader, json) {
  method decode (line 486) | static decode(reader, position) {
  method decodeText (line 493) | static decodeText(reader, json) {
  method decode (line 503) | static decode(reader, position) {
  method decodeText (line 510) | static decodeText(reader, json) {
  method decode (line 529) | static decode(reader, position) {
  method decodeText (line 535) | static decodeText(reader, json) {
  method decode (line 544) | static decode(reader, position) {
  method decodeText (line 551) | static decodeText(reader, json) {
  method decode (line 561) | static decode(reader, position) {
  method decodeText (line 568) | static decodeText(reader, json) {
  method decode (line 578) | static decode(reader, position) {
  method decodeText (line 587) | static decodeText(reader, json) {
  method decode (line 599) | static decode(reader, position) {
  method decodeText (line 614) | static decodeText(reader, json) {
  method decode (line 632) | static decode(reader, position) {
  method decodeText (line 639) | static decodeText(reader, json) {
  method decode (line 649) | static decode(reader, position) {
  method decodeText (line 668) | static decodeText(reader, json) {
  method decode (line 690) | static decode(reader, position) {
  method decodeText (line 697) | static decodeText(reader, json) {
  method decode (line 707) | static decode(reader, position) {
  method decodeText (line 714) | static decodeText(reader, json) {
  method decode (line 724) | static decode(reader, position) {
  method decodeText (line 730) | static decodeText(reader, json) {
  method decode (line 751) | static decode(reader, position) {
  method decodeText (line 757) | static decodeText(reader, json) {
  method decode (line 766) | static decode(reader, position) {
  method decodeText (line 773) | static decodeText(reader, json) {
  method decode (line 795) | static decode(reader, position) {
  method decodeText (line 801) | static decodeText(reader, json) {
  method decode (line 810) | static decode(reader, position) {
  method decodeText (line 817) | static decodeText(reader, json) {
  method decode (line 827) | static decode(reader, position) {
  method decodeText (line 833) | static decodeText(reader, json) {
  method decode (line 842) | static decode(reader, position) {
  method decodeText (line 849) | static decodeText(reader, json) {
  method decode (line 859) | static decode(reader, position) {
  method decodeText (line 865) | static decodeText(reader, json) {
  method decode (line 874) | static decode(reader, position) {
  method decodeText (line 880) | static decodeText(reader, json) {
  method decode (line 889) | static decode(reader, position) {
  method decodeText (line 898) | static decodeText(reader, json) {
  method decode (line 910) | static decode(reader, position) {
  method decodeText (line 918) | static decodeText(reader, json) {
  method decode (line 929) | static decode(reader, position) {
  method decodeText (line 936) | static decodeText(reader, json) {
  method decode (line 946) | static decode(reader, position) {
  method decodeText (line 952) | static decodeText(reader, json) {
  method decode (line 961) | static decode(reader, position) {
  method decodeText (line 967) | static decodeText(reader, json) {
  method decode (line 976) | static decode(reader, position) {
  method decodeText (line 982) | static decodeText(reader, json) {
  method decode (line 991) | static decode(reader, position) {
  method decodeText (line 997) | static decodeText(reader, json) {
  method decode (line 1006) | static decode(reader, position) {
  method decodeText (line 1013) | static decodeText(reader, json) {
  method decode (line 1023) | static decode(reader, position) {
  method decodeText (line 1032) | static decodeText(reader, json) {
  method decode (line 1044) | static decode(reader, position) {
  method decodeText (line 1051) | static decodeText(reader, json) {
  method decode (line 1061) | static decode(reader, position) {
  method decodeText (line 1068) | static decodeText(reader, json) {
  method decode (line 1078) | static decode(reader, position) {
  method decodeText (line 1085) | static decodeText(reader, json) {
  method decode (line 1095) | static decode(reader, position) {
  method decodeText (line 1102) | static decodeText(reader, json) {
  method decode (line 1117) | static decode(reader, position) {
  method decodeText (line 1123) | static decodeText(reader, json) {
  method decode (line 1132) | static decode(reader, position) {
  method decodeText (line 1139) | static decodeText(reader, json) {
  method decode (line 1149) | static decode(reader, position) {
  method decodeText (line 1155) | static decodeText(reader, json) {
  method decode (line 1164) | static decode(reader, position) {
  method decodeText (line 1170) | static decodeText(reader, json) {
  method decode (line 1179) | static decode(reader, position) {
  method decodeText (line 1185) | static decodeText(reader, json) {
  method decode (line 1194) | static decode(reader, position) {
  method decodeText (line 1201) | static decodeText(reader, json) {
  method decode (line 1211) | static decode(reader, position) {
  method decodeText (line 1218) | static decodeText(reader, json) {
  method decode (line 1244) | static decode(reader, position) {
  method decodeText (line 1261) | static decodeText(reader, json) {
  method decode (line 1281) | static decode(reader, position) {
  method decodeText (line 1302) | static decodeText(reader, json) {
  method decode (line 1326) | static decode(reader, position) {
  method decodeText (line 1332) | static decodeText(reader, json) {
  method decode (line 1341) | static decode(reader, position) {
  method decodeText (line 1348) | static decodeText(reader, json) {
  method decode (line 1358) | static decode(reader, position) {
  method decodeText (line 1365) | static decodeText(reader, json) {
  method decode (line 1375) | static decode(reader, position) {
  method decodeText (line 1384) | static decodeText(reader, json) {
  method decode (line 1396) | static decode(reader, position) {
  method decodeText (line 1411) | static decodeText(reader, json) {
  method decode (line 1429) | static decode(reader, position) {
  method decodeText (line 1435) | static decodeText(reader, json) {
  method decode (line 1444) | static decode(reader, position) {
  method decodeText (line 1451) | static decodeText(reader, json) {
  method decode (line 1461) | static decode(reader, position) {
  method decodeText (line 1467) | static decodeText(reader, json) {
  method decode (line 1476) | static decode(reader, position) {
  method decodeText (line 1483) | static decodeText(reader, json) {
  method decode (line 1493) | static decode(reader, position) {
  method decodeText (line 1499) | static decodeText(reader, json) {
  method decode (line 1508) | static decode(reader, position) {
  method decodeText (line 1514) | static decodeText(reader, json) {
  method decode (line 1523) | static decode(reader, position) {
  method decodeText (line 1530) | static decodeText(reader, json) {
  method decode (line 1540) | static decode(reader, position) {
  method decodeText (line 1548) | static decodeText(reader, json) {
  method decode (line 1559) | static decode(reader, position) {
  method decodeText (line 1566) | static decodeText(reader, json) {
  method decode (line 1576) | static decode(reader, position) {
  method decodeText (line 1583) | static decodeText(reader, json) {
  method decode (line 1593) | static decode(reader, position) {
  method decodeText (line 1599) | static decodeText(reader, json) {
  method decode (line 1608) | static decode(reader, position) {
  method decodeText (line 1615) | static decodeText(reader, json) {
  method decode (line 1625) | static decode(reader, position) {
  method decodeText (line 1633) | static decodeText(reader, json) {
  method decode (line 1654) | static decode(reader, position) {
  method decodeText (line 1661) | static decodeText(reader, json) {
  method decode (line 1671) | static decode(reader, position) {
  method decodeText (line 1683) | static decodeText(reader, json) {
  method decode (line 1698) | static decode(reader, position) {
  method decodeText (line 1705) | static decodeText(reader, json) {
  method decode (line 1715) | static decode(reader, position) {
  method decodeText (line 1722) | static decodeText(reader, json) {
  method decode (line 1732) | static decode(reader, position) {
  method decodeText (line 1739) | static decodeText(reader, json) {
  method decode (line 1755) | static decode(reader, position) {
  method decodeText (line 1763) | static decodeText(reader, json) {
  method decode (line 1774) | static decode(reader, position) {
  method decodeText (line 1780) | static decodeText(reader, json) {
  method decode (line 1789) | static decode(reader, position) {
  method decodeText (line 1800) | static decodeText(reader, json) {
  method decode (line 1814) | static decode(reader, position) {
  method decodeText (line 1821) | static decodeText(reader, json) {
  method decode (line 1831) | static decode(reader, position) {
  method decodeText (line 1838) | static decodeText(reader, json) {
  method decode (line 1848) | static decode(reader, position) {
  method decodeText (line 1858) | static decodeText(reader, json) {
  method decode (line 1871) | static decode(reader, position) {
  method decodeText (line 1878) | static decodeText(reader, json) {
  method decode (line 1888) | static decode(reader, position) {
  method decodeText (line 1895) | static decodeText(reader, json) {
  method decode (line 1905) | static decode(reader, position) {
  method decodeText (line 1912) | static decodeText(reader, json) {
  method decode (line 1922) | static decode(reader, position) {
  method decodeText (line 1936) | static decodeText(reader, json) {
  method decode (line 1953) | static decode(reader, position) {
  method decodeText (line 1960) | static decodeText(reader, json) {
  method decode (line 1970) | static decode(reader, position) {
  method decodeText (line 1977) | static decodeText(reader, json) {
  method decode (line 1987) | static decode(reader, position) {
  method decodeText (line 1993) | static decodeText(reader, json) {
  method decode (line 2002) | static decode(reader, position) {
  method decodeText (line 2011) | static decodeText(reader, json) {
  method decode (line 2023) | static decode(reader, position) {
  method decodeText (line 2032) | static decodeText(reader, json) {
  method decode (line 2044) | static decode(reader, position) {
  method decodeText (line 2051) | static decodeText(reader, json) {
  method decode (line 2061) | static decode(reader, position) {
  method decodeText (line 2069) | static decodeText(reader, json) {
  method decode (line 2080) | static decode(reader, position) {
  method decodeText (line 2096) | static decodeText(reader, json) {
  method decode (line 2115) | static decode(reader, position) {
  method decodeText (line 2141) | static decodeText(reader, json) {
  method decode (line 2170) | static decode(reader, position) {
  method decodeText (line 2182) | static decodeText(reader, json) {
  method decode (line 2197) | static decode(reader, position) {
  method decodeText (line 2205) | static decodeText(reader, json) {
  method decode (line 2216) | static decode(reader, position) {
  method decodeText (line 2242) | static decodeText(reader, json) {
  method decode (line 2271) | static decode(reader, position) {
  method decodeText (line 2288) | static decodeText(reader, json) {
  method decode (line 2308) | static decode(reader, position) {
  method decodeText (line 2316) | static decodeText(reader, json) {
  method decode (line 2327) | static decode(reader, position) {
  method decodeText (line 2344) | static decodeText(reader, json) {
  method decode (line 2364) | static decode(reader, position) {
  method decodeText (line 2371) | static decodeText(reader, json) {
  method decode (line 2381) | static decode(reader, position) {
  method decodeText (line 2387) | static decodeText(reader, json) {
  method decode (line 2396) | static decode(reader, position) {
  method decodeText (line 2402) | static decodeText(reader, json) {
  method decode (line 2411) | static decode(reader, position) {
  method decodeText (line 2417) | static decodeText(reader, json) {
  method decode (line 2426) | static decode(reader, position) {
  method decodeText (line 2432) | static decodeText(reader, json) {
  method decode (line 2441) | static decode(reader, position) {
  method decodeText (line 2450) | static decodeText(reader, json) {
  method decode (line 2462) | static decode(reader, position) {
  method decodeText (line 2475) | static decodeText(reader, json) {
  method decode (line 2491) | static decode(reader, position) {
  method decodeText (line 2498) | static decodeText(reader, json) {
  method decode (line 2508) | static decode(reader, position) {
  method decodeText (line 2514) | static decodeText(reader, json) {
  method decode (line 2523) | static decode(reader, position) {
  method decodeText (line 2530) | static decodeText(reader, json) {
  method decode (line 2540) | static decode(reader, position) {
  method decodeText (line 2551) | static decodeText(reader, json) {
  method decode (line 2565) | static decode(reader, position) {
  method decodeText (line 2571) | static decodeText(reader, json) {
  method decode (line 2580) | static decode(reader, position) {
  method decodeText (line 2587) | static decodeText(reader, json) {
  method decode (line 2597) | static decode(reader, position) {
  method decodeText (line 2605) | static decodeText(reader, json) {
  method decode (line 2616) | static decode(reader, position) {
  method decodeText (line 2623) | static decodeText(reader, json) {
  method decode (line 2633) | static decode(reader, position) {
  method decodeText (line 2640) | static decodeText(reader, json) {
  method decode (line 2650) | static decode(reader, position) {
  method decodeText (line 2656) | static decodeText(reader, json) {
  method decode (line 2665) | static decode(reader, position) {
  method decodeText (line 2672) | static decodeText(reader, json) {
  method decode (line 2682) | static decode(reader, position) {
  method decodeText (line 2690) | static decodeText(reader, json) {
  method decode (line 2701) | static decode(reader, position) {
  method decodeText (line 2714) | static decodeText(reader, json) {
  method decode (line 2730) | static decode(reader, position) {
  method decodeText (line 2738) | static decodeText(reader, json) {
  method decode (line 2749) | static decode(reader, position) {
  method decodeText (line 2760) | static decodeText(reader, json) {
  method decode (line 2774) | static decode(reader, position) {
  method decodeText (line 2781) | static decodeText(reader, json) {
  method decode (line 2791) | static decode(reader, position) {
  method decodeText (line 2797) | static decodeText(reader, json) {
  method decode (line 2806) | static decode(reader, position) {
  method decodeText (line 2813) | static decodeText(reader, json) {
  method decode (line 2823) | static decode(reader, position) {
  method decodeText (line 2832) | static decodeText(reader, json) {
  method decode (line 2844) | static decode(reader, position) {
  method decodeText (line 2851) | static decodeText(reader, json) {
  method decode (line 2861) | static decode(reader, position, type) {
  method decodeText (line 2940) | static decodeText(reader, json, type) {
  method decode (line 3022) | static decode(reader, position) {
  method decodeText (line 3028) | static decodeText(reader, json) {
  method decode (line 3037) | static decode(reader, position) {
  method decodeText (line 3045) | static decodeText(reader, json) {
  method identifier (line 3056) | static identifier(reader) {
  method create (line 3060) | static create(reader) {
  method createText (line 3064) | static createText(reader) {
  method decode (line 3068) | static decode(reader, position) {
  method decodeText (line 3077) | static decodeText(reader, json) {

FILE: source/armnn.js
  method match (line 6) | async match(context) {
  method open (line 24) | async open(context) {
  method constructor (line 60) | constructor(metadata, model) {
  method constructor (line 68) | constructor(metadata, graph) {
  method constructor (line 141) | constructor(metadata, layer, value) {
  method getBase (line 195) | static getBase(layer) {
  method makeKey (line 199) | static makeKey(layer_id, index) {
  method constructor (line 206) | constructor(name, value, type = null) {
  method constructor (line 215) | constructor(name, tensorInfo, initializer) {
  method constructor (line 238) | constructor(tensor, category = '') {
  method constructor (line 248) | constructor(tensorInfo) {
  method toString (line 267) | toString() {
  method constructor (line 274) | constructor(dimensions) {
  method toString (line 278) | toString() {
  method constructor (line 288) | constructor(message) {

FILE: source/barracuda.js
  method match (line 8) | async match(context) {
  method open (line 19) | async open(context) {
  method constructor (line 29) | constructor(metadata, model) {
  method constructor (line 38) | constructor(metadata, model) {
  method constructor (line 82) | constructor(name, value, type = null) {
  method constructor (line 91) | constructor(name, type = null, initializer = null) {
  method constructor (line 100) | constructor(metadata, layer, type, values) {
  method constructor (line 163) | constructor(tensor) {
  method constructor (line 171) | constructor(itemsize, shape) {
  method toString (line 179) | toString() {
  method constructor (line 186) | constructor(dimensions) {
  method toString (line 190) | toString() {
  method constructor (line 197) | constructor(reader) {
  method constructor (line 269) | constructor(reader) {
  method position (line 273) | get position() {
  method seek (line 277) | seek(position) {
  method skip (line 281) | skip(offset) {
  method read (line 285) | read(length) {
  method byte (line 289) | byte() {
  method int32 (line 293) | int32() {
  method int32s (line 297) | int32s() {
  method int64 (line 305) | int64() {
  method float32 (line 309) | float32() {
  method string (line 313) | string() {
  method strings (line 323) | strings() {
  method shape (line 332) | shape() {
  method open (line 339) | static open() {
  method constructor (line 344) | constructor() {
  method type (line 431) | type(name) {
  method constructor (line 441) | constructor(message) {

FILE: source/base.js
  method constructor (line 6) | constructor(real, imaginary) {
  method toString (line 11) | toString(/* radix */) {
  method constructor (line 374) | constructor(buffer) {
  method position (line 380) | get position() {
  method length (line 384) | get length() {
  method stream (line 388) | stream(length) {
  method seek (line 393) | seek(position) {
  method skip (line 400) | skip(offset) {
  method peek (line 407) | peek(length) {
  method read (line 418) | read(length) {
  method open (line 431) | static open(data, littleEndian) {
  method constructor (line 441) | constructor(data, littleEndian) {
  method length (line 449) | get length() {
  method position (line 453) | get position() {
  method seek (line 457) | seek(position) {
  method skip (line 464) | skip(offset) {
  method align (line 471) | align(size) {
  method stream (line 478) | stream(length) {
  method peek (line 483) | peek(length) {
  method read (line 494) | read(length) {
  method byte (line 504) | byte() {
  method int8 (line 510) | int8() {
  method int16 (line 516) | int16() {
  method int32 (line 522) | int32() {
  method int64 (line 528) | int64() {
  method uint16 (line 534) | uint16() {
  method uint32 (line 540) | uint32() {
  method uint64 (line 546) | uint64() {
  method float32 (line 552) | float32() {
  method float64 (line 558) | float64() {
  method string (line 564) | string() {
  method boolean (line 573) | boolean() {
  method constructor (line 580) | constructor(stream, littleEndian) {
  method position (line 587) | get position() {
  method length (line 591) | get length() {
  method seek (line 595) | seek(position) {
  method skip (line 599) | skip(offset) {
  method align (line 603) | align(size) {
  method stream (line 610) | stream(length) {
  method peek (line 614) | peek(length) {
  method read (line 618) | read(length) {
  method byte (line 622) | byte() {
  method int8 (line 626) | int8() {
  method int16 (line 632) | int16() {
  method int32 (line 638) | int32() {
  method int64 (line 644) | int64() {
  method uint16 (line 650) | uint16() {
  method uint32 (line 656) | uint32() {
  method uint64 (line 662) | uint64() {
  method float32 (line 668) | float32() {
  method float64 (line 674) | float64() {
  method boolean (line 680) | boolean() {
  method constructor (line 687) | constructor(tensor) {
  method values (line 708) | get values() {
  method indices (line 713) | get indices() {
  method data (line 718) | get data() {
  method metrics (line 726) | get metrics() {
  method empty (line 730) | get empty() {
  method value (line 750) | get value() {
  method toString (line 767) | toString() {
  method _context (line 786) | _context() {
  method _decodeSparse (line 899) | _decodeSparse(dataType, dimensions, indices, values) {
  method _decodeData (line 925) | _decodeData(context, dimension, offset) {
  method _decodeValues (line 1112) | _decodeValues(context, dimension, position) {
  method _stringify (line 1154) | static _stringify(value, indentation, indent) {
  method _read (line 1193) | _read() {
  method constructor (line 1233) | constructor(window) {
  method start (line 1270) | async start(measurement_id, client_id, session) {
  method session (line 1323) | get session() {
  method set (line 1327) | set(name, value) {
  method get (line 1337) | get(name) {
  method send (line 1342) | send(name, params) {
  method _update (line 1365) | _update(focused, page, visible) {
  method extensions (line 1383) | get extensions() {

FILE: source/bigdl-proto.js
  method constructor (line 15) | constructor() {
  method decode (line 26) | static decode(reader, length) {
  method constructor (line 169) | constructor() {
  method decode (line 173) | static decode(reader, length) {
  method constructor (line 198) | constructor() {
  method decode (line 203) | static decode(reader, length) {
  method constructor (line 259) | constructor() {
  method decode (line 269) | static decode(reader, length) {
  method constructor (line 316) | constructor() {
  method decode (line 320) | static decode(reader, length) {
  method value (line 367) | get value() {
  method decode (line 372) | static decode(reader, length) {
  method constructor (line 446) | constructor() {
  method decode (line 464) | static decode(reader, length) {
  method constructor (line 535) | constructor() {
  method decode (line 539) | static decode(reader, length) {
  method constructor (line 564) | constructor() {
  method decode (line 569) | static decode(reader, length) {
  method decode (line 608) | static decode(reader, length) {

FILE: source/bigdl.js
  method match (line 8) | async match(context) {
  method open (line 17) | async open(context) {
  method constructor (line 36) | constructor(metadata, module) {
  method constructor (line 45) | constructor(metadata, module) {
  method constructor (line 85) | constructor(name, value, type = null) {
  method constructor (line 94) | constructor(name, type, initializer) {
  method constructor (line 106) | constructor(metadata, module, tensors, values) {
  method constructor (line 239) | constructor(tensor /*, tensors */) {
  method constructor (line 265) | constructor(dataType, shape) {
  method toString (line 274) | toString() {
  method constructor (line 281) | constructor(dimensions) {
  method toString (line 288) | toString() {
  method constructor (line 295) | constructor(message) {

FILE: source/browser.js
  method constructor (line 8) | constructor() {
  method window (line 39) | get window() {
  method document (line 43) | get document() {
  method version (line 47) | get version() {
  method type (line 51) | get type() {
  method view (line 55) | async view(view) {
  method start (line 148) | async start() {
  method environment (line 224) | environment(name) {
  method require (line 228) | async require(id) {
  method worker (line 232) | worker(id) {
  method save (line 237) | async save(name, extension, defaultPath) {
  method export (line 241) | async export(file, blob) {
  method execute (line 254) | async execute(name /*, value */) {
  method request (line 278) | async request(file, encoding, base) {
  method openURL (line 292) | openURL(url) {
  method exception (line 297) | exception(error, fatal) {
  method event (line 347) | event(name, params) {
  method _request (line 355) | async _request(url, headers, encoding, callback, timeout) {
  method _url (line 420) | _url(file) {
  method _openModel (line 432) | async _openModel(url, identifier, name) {
  method _open (line 458) | async _open(file, files) {
  method _openGist (line 469) | async _openGist(gist) {
  method _openContext (line 500) | async _openContext(context) {
  method _setCookie (line 523) | _setCookie(name, value, days) {
  method _getCookie (line 534) | _getCookie(name) {
  method get (line 545) | get(name) {
  method set (line 558) | set(name, value) {
  method delete (line 569) | delete(name) {
  method _element (line 580) | _element(id) {
  method update (line 585) | update() {
  method message (line 588) | async message(message, alert, action) {
  method constructor (line 621) | constructor(host, file, blobs) {
  method identifier (line 630) | get identifier() {
  method stream (line 634) | get stream() {
  method request (line 638) | async request(file, encoding, basename) {
  method require (line 702) | async require(id) {
  method error (line 706) | error(error, fatal) {
  method open (line 710) | async open() {
  method constructor (line 717) | constructor(chunks, size, start, length) {
  method position (line 725) | get position() {
  method length (line 729) | get length() {
  method stream (line 733) | stream(length) {
  method seek (line 739) | seek(position) {
  method skip (line 743) | skip(offset) {
  method peek (line 750) | peek(length) {
  method read (line 770) | read(length) {
  method _fill (line 790) | _fill(length) {
  method _read (line 807) | _read(buffer, offset) {
  method constructor (line 824) | constructor(host, url, identifier, name, stream) {
  method identifier (line 836) | get identifier() {
  method name (line 840) | get name() {
  method stream (line 844) | get stream() {
  method request (line 848) | async request(file, encoding, base) {
  method require (line 853) | async require(id) {
  method error (line 857) | error(error, fatal) {

FILE: source/caffe-proto.js
  method constructor (line 6) | constructor() {
  method decode (line 10) | static decode(reader, length) {
  method decodeText (line 27) | static decodeText(reader) {
  method constructor (line 47) | constructor() {
  method decode (line 54) | static decode(reader, length) {
  method decodeText (line 95) | static decodeText(reader) {
  method constructor (line 145) | constructor() {
  method decode (line 149) | static decode(reader, length) {
  method decodeText (line 166) | static decodeText(reader) {
  method constructor (line 186) | constructor() {
  method decode (line 190) | static decode(reader, length) {
  method decodeText (line 225) | static decodeText(reader) {
  method decode (line 270) | static decode(reader, length) {
  method decodeText (line 308) | static decodeText(reader) {
  method constructor (line 364) | constructor() {
  method decode (line 372) | static decode(reader, length) {
  method decodeText (line 413) | static decodeText(reader) {
  method constructor (line 462) | constructor() {
  method decode (line 471) | static decode(reader, length) {
  method decodeText (line 611) | static decodeText(reader) {
  method constructor (line 810) | constructor() {
  method decode (line 814) | static decode(reader, length) {
  method decodeText (line 840) | static decodeText(reader) {
  method constructor (line 878) | constructor() {
  method decode (line 882) | static decode(reader, length) {
  method decodeText (line 905) | static decodeText(reader) {
  method constructor (line 934) | constructor() {
  method decode (line 939) | static decode(reader, length) {
  method decodeText (line 968) | static decodeText(reader) {
  method decode (line 1004) | static decode(reader, length) {
  method decodeText (line 1030) | static decodeText(reader) {
  method constructor (line 1069) | constructor() {
  method decode (line 1080) | static decode(reader, length) {
  method decodeText (line 1274) | static decodeText(reader) {
  method constructor (line 1524) | constructor() {
  method decode (line 1528) | static decode(reader, length) {
  method decodeText (line 1563) | static decodeText(reader) {
  method decode (line 1608) | static decode(reader, length) {
  method decodeText (line 1631) | static decodeText(reader) {
  method decode (line 1668) | static decode(reader, length) {
  method decodeText (line 1691) | static decodeText(reader) {
  method decode (line 1721) | static decode(reader, length) {
  method decodeText (line 1744) | static decodeText(reader) {
  method decode (line 1774) | static decode(reader, length) {
  method decodeText (line 1794) | static decodeText(reader) {
  method decode (line 1820) | static decode(reader, length) {
  method decodeText (line 1840) | static decodeText(reader) {
  method decode (line 1866) | static decode(reader, length) {
  method decodeText (line 1889) | static decodeText(reader) {
  method decode (line 1919) | static decode(reader, length) {
  method decodeText (line 1942) | static decodeText(reader) {
  method decode (line 1972) | static decode(reader, length) {
  method decodeText (line 1992) | static decodeText(reader) {
  method constructor (line 2018) | constructor() {
  method decode (line 2025) | static decode(reader, length) {
  method decodeText (line 2093) | static decodeText(reader) {
  method constructor (line 2185) | constructor() {
  method decode (line 2189) | static decode(reader, length) {
  method decodeText (line 2209) | static decodeText(reader) {
  method decode (line 2234) | static decode(reader, length) {
  method decodeText (line 2278) | static decodeText(reader) {
  method decode (line 2341) | static decode(reader, length) {
  method decodeText (line 2358) | static decodeText(reader) {
  method constructor (line 2380) | constructor() {
  method decode (line 2389) | static decode(reader, length) {
  method decodeText (line 2421) | static decodeText(reader) {
  method constructor (line 2456) | constructor() {
  method decode (line 2460) | static decode(reader, length) {
  method decodeText (line 2483) | static decodeText(reader) {
  method decode (line 2518) | static decode(reader, length) {
  method decodeText (line 2535) | static decodeText(reader) {
  method decode (line 2557) | static decode(reader, length) {
  method decodeText (line 2586) | static decodeText(reader) {
  method decode (line 2624) | static decode(reader, length) {
  method decodeText (line 2647) | static decodeText(reader) {
  method decode (line 2677) | static decode(reader, length) {
  method decodeText (line 2697) | static decodeText(reader) {
  method decode (line 2723) | static decode(reader, length) {
  method decodeText (line 2746) | static decodeText(reader) {
  method decode (line 2776) | static decode(reader, length) {
  method decodeText (line 2793) | static decodeText(reader) {
  method decode (line 2815) | static decode(reader, length) {
  method decodeText (line 2832) | static decodeText(reader) {
  method decode (line 2859) | static decode(reader, length) {
  method decodeText (line 2909) | static decodeText(reader) {
  method decode (line 2975) | static decode(reader, length) {
  method decodeText (line 2995) | static decodeText(reader) {
  method decode (line 3021) | static decode(reader, length) {
  method decodeText (line 3053) | static decodeText(reader) {
  method constructor (line 3095) | constructor() {
  method decode (line 3099) | static decode(reader, length) {
  method decodeText (line 3116) | static decodeText(reader) {
  method decode (line 3136) | static decode(reader, length) {
  method decodeText (line 3159) | static decodeText(reader) {
  method decode (line 3189) | static decode(reader, length) {
  method decodeText (line 3221) | static decodeText(reader) {
  method decode (line 3274) | static decode(reader, length) {
  method decodeText (line 3300) | static decodeText(reader) {
  method decode (line 3334) | static decode(reader, length) {
  method decodeText (line 3357) | static decodeText(reader) {
  method decode (line 3387) | static decode(reader, length) {
  method decodeText (line 3404) | static decodeText(reader) {
  method decode (line 3426) | static decode(reader, length) {
  method decodeText (line 3479) | static decodeText(reader) {
  method decode (line 3566) | static decode(reader, length) {
  method decodeText (line 3589) | static decodeText(reader) {
  method decode (line 3619) | static decode(reader, length) {
  method decodeText (line 3645) | static decodeText(reader) {
  method decode (line 3679) | static decode(reader, length) {
  method decodeText (line 3708) | static decodeText(reader) {
  method decode (line 3746) | static decode(reader, length) {
  method decodeText (line 3769) | static decodeText(reader) {
  method decode (line 3806) | static decode(reader, length) {
  method decodeText (line 3826) | static decodeText(reader) {
  method decode (line 3858) | static decode(reader, length) {
  method decodeText (line 3881) | static decodeText(reader) {
  method decode (line 3911) | static decode(reader, length) {
  method decodeText (line 3940) | static decodeText(reader) {
  method decode (line 3978) | static decode(reader, length) {
  method decodeText (line 3995) | static decodeText(reader) {
  method constructor (line 4023) | constructor() {
  method decode (line 4027) | static decode(reader, length) {
  method decodeText (line 4050) | static decodeText(reader) {
  method decode (line 4079) | static decode(reader, length) {
  method decodeText (line 4099) | static decodeText(reader) {
  method decode (line 4131) | static decode(reader, length) {
  method decodeText (line 4148) | static decodeText(reader) {
  method decode (line 4170) | static decode(reader, length) {
  method decodeText (line 4187) | static decodeText(reader) {
  method decode (line 4215) | static decode(reader, length) {
  method decodeText (line 4235) | static decodeText(reader) {
  method decode (line 4261) | static decode(reader, length) {
  method decodeText (line 4278) | static decodeText(reader) {
  method decode (line 4300) | static decode(reader, length) {
  method decodeText (line 4353) | static decodeText(reader) {
  method decode (line 4423) | static decode(reader, length) {
  method decodeText (line 4446) | static decodeText(reader) {
  method constructor (line 4488) | constructor() {
  method decode (line 4501) | static decode(reader, length) {
  method decodeText (line 4644) | static decodeText(reader) {
  method constructor (line 4872) | constructor() {
  method decode (line 4878) | static decode(reader, length) {
  method decodeText (line 5006) | static decodeText(reader) {
  method decode (line 5179) | static decode(reader, length) {
  method decodeText (line 5199) | static decodeText(reader) {

FILE: source/caffe.js
  method match (line 6) | async match(context) {
  method open (line 26) | async open(context) {
  method _decodeText (line 131) | static _decodeText(reader) {
  method constructor (line 152) | constructor(metadata, net) {
  method constructor (line 189) | constructor(metadata, phase, net, version) {
  method constructor (line 319) | constructor(name, value, type = null, visible = true) {
  method constructor (line 329) | constructor(name, type = null, initializer = null) {
  method constructor (line 341) | constructor(metadata, layer, version, value) {
  method constructor (line 488) | constructor(blob) {
  method constructor (line 525) | constructor(dataType, shape) {
  method toString (line 530) | toString() {
  method constructor (line 537) | constructor(dimensions) {
  method toString (line 541) | toString() {
  method layerType (line 548) | static layerType(type) {
  method enum (line 561) | static enum(name, value) {
  method constructor (line 584) | constructor(message) {

FILE: source/caffe2-proto.js
  method constructor (line 6) | constructor() {
  method decode (line 15) | static decode(reader, length) {
  method decodeText (line 68) | static decodeText(reader) {
  method decode (line 155) | static decode(reader, length) {
  method decodeText (line 181) | static decodeText(reader) {
  method constructor (line 213) | constructor() {
  method decode (line 220) | static decode(reader, length) {
  method decodeText (line 282) | static decodeText(reader) {
  method constructor (line 356) | constructor() {
  method decode (line 360) | static decode(reader, length) {
  method decodeText (line 377) | static decodeText(reader) {
  method constructor (line 397) | constructor() {
  method decode (line 402) | static decode(reader, length) {
  method decodeText (line 431) | static decodeText(reader) {
  method constructor (line 467) | constructor() {
  method decode (line 471) | static decode(reader, length) {
  method decodeText (line 488) | static decodeText(reader) {
  method constructor (line 508) | constructor() {
  method decode (line 512) | static decode(reader, length) {
  method decodeText (line 538) | static decodeText(reader) {
  method constructor (line 581) | constructor() {
  method decode (line 585) | static decode(reader, length) {
  method decodeText (line 608) | static decodeText(reader) {
  method decode (line 637) | static decode(reader, length) {
  method decodeText (line 675) | static decodeText(reader) {
  method constructor (line 722) | constructor() {
  method decode (line 731) | static decode(reader, length) {
  method decodeText (line 781) | static decodeText(reader) {
  method constructor (line 856) | constructor() {
  method decode (line 860) | static decode(reader, length) {
  method decodeText (line 892) | static decodeText(reader) {
  method constructor (line 933) | constructor() {
  method decode (line 940) | static decode(reader, length) {
  method decodeText (line 990) | static decodeText(reader) {
  method decode (line 1052) | static decode(reader, length) {
  method decodeText (line 1078) | static decodeText(reader) {
  method constructor (line 1110) | constructor() {
  method decode (line 1114) | static decode(reader, length) {
  method decodeText (line 1137) | static decodeText(reader) {
  method constructor (line 1165) | constructor() {
  method decode (line 1170) | static decode(reader, length) {
  method decodeText (line 1199) | static decodeText(reader) {
  method constructor (line 1234) | constructor() {
  method decode (line 1242) | static decode(reader, length) {
  method decodeText (line 1283) | static decodeText(reader) {
  method constructor (line 1332) | constructor() {
  method decode (line 1337) | static decode(reader, length) {
  method decodeText (line 1390) | static decodeText(reader) {
  method constructor (line 1458) | constructor() {
  method decode (line 1463) | static decode(reader, length) {
  method decodeText (line 1486) | static decodeText(reader) {
  method decode (line 1514) | static decode(reader, length) {
  method decodeText (line 1549) | static decodeText(reader) {
  method decode (line 1595) | static decode(reader, length) {
  method decodeText (line 1621) | static decodeText(reader) {
  method decode (line 1655) | static decode(reader, length) {
  method decodeText (line 1678) | static decodeText(reader) {
  method constructor (line 1714) | constructor() {
  method decode (line 1718) | static decode(reader, length) {
  method decodeText (line 1735) | static decodeText(reader) {

FILE: source/caffe2.js
  method match (line 6) | async match(context) {
  method open (line 58) | async open(context) {
  method constructor (line 196) | constructor(metadata, predict_net, init_net) {
  method constructor (line 206) | constructor(metadata, predict_net, init_net) {
  method constructor (line 331) | constructor(name, value, type = null, visible = true) {
  method constructor (line 341) | constructor(name, type, initializer = null) {
  method constructor (line 354) | constructor(metadata, op, values) {
  method constructor (line 434) | constructor(name, tensor) {
  method constructor (line 462) | constructor(dataType, shape) {
  method toString (line 467) | toString() {
  method constructor (line 474) | constructor(dimensions) {
  method toString (line 478) | toString() {
  method constructor (line 488) | constructor(message) {

FILE: source/catboost-schema.js
  method decode (line 6) | static decode(reader, position) {
  method decode (line 24) | static decode(reader, position) {
  method decode (line 38) | static decode(reader, position) {
  method decode (line 50) | static decode(reader, position) {
  method decode (line 62) | static decode(reader, position) {
  method decode (line 80) | static decode(reader, position) {
  method decode (line 93) | static decode(reader, position) {
  method decode (line 104) | static decode(reader, position) {
  method decode (line 114) | static decode(reader, position) {
  method decode (line 124) | static decode(reader, position) {
  method decode (line 144) | static decode(reader, position) {
  method decode (line 155) | static decode(reader, position) {
  method decode (line 169) | static decode(reader, position) {
  method create (line 179) | static create(reader) {
  method decode (line 183) | static decode(reader, position) {
  method decode (line 196) | static decode(reader, position) {
  method decode (line 206) | static decode(reader, position) {
  method decode (line 216) | static decode(reader, position) {
  method decode (line 227) | static decode(reader, position) {
  method create (line 254) | static create(reader) {
  method decode (line 258) | static decode(reader, position) {

FILE: source/catboost.js
  method match (line 9) | async match(context) {
  method open (line 28) | async open(context) {
  method constructor (line 60) | constructor(obj) {
  method constructor (line 72) | constructor(obj) {
  method constructor (line 108) | constructor(name, value) {
  method constructor (line 116) | constructor(name, type) {
  method constructor (line 124) | constructor(dataType) {
  method toString (line 129) | toString() {
  method constructor (line 136) | constructor(obj, features) {
  method constructor (line 181) | constructor(message) {

FILE: source/circle-schema.js
  method decode (line 35) | static decode(reader, position) {
  method decodeText (line 41) | static decodeText(reader, json) {
  method decode (line 50) | static decode(reader, position) {
  method decodeText (line 56) | static decodeText(reader, json) {
  method decode (line 65) | static decode(reader, position, type) {
  method decodeText (line 74) | static decodeText(reader, json, type) {
  method decode (line 86) | static decode(reader, position) {
  method decodeText (line 94) | static decodeText(reader, json) {
  method decode (line 105) | static decode(reader, position) {
  method decodeText (line 116) | static decodeText(reader, json) {
  method decode (line 135) | static decode(reader, position) {
  method decodeText (line 141) | static decodeText(reader, json) {
  method decode (line 150) | static decode(reader, position) {
  method decodeText (line 156) | static decodeText(reader, json) {
  method decode (line 165) | static decode(reader, position) {
  method decodeText (line 171) | static decodeText(reader, json) {
  method decode (line 180) | static decode(reader, position, type) {
  method decodeText (line 189) | static decodeText(reader, json, type) {
  method decode (line 201) | static decode(reader, position) {
  method decodeText (line 210) | static decodeText(reader, json) {
  method decode (line 222) | static decode(reader, position) {
  method decodeText (line 230) | static decodeText(reader, json) {
  method decode (line 241) | static decode(reader, position) {
  method decodeText (line 249) | static decodeText(reader, json) {
  method decode (line 265) | static decode(reader, position) {
  method decodeText (line 281) | static decodeText(reader, json) {
  method decode (line 521) | static decode(reader, position, type) {
  method decodeText (line 661) | static decodeText(reader, json, type) {
  method decode (line 804) | static decode(reader, position, type) {
  method decodeText (line 833) | static decodeText(reader, json, type) {
  method decode (line 865) | static decode(reader, position) {
  method decodeText (line 876) | static decodeText(reader, json) {
  method decode (line 890) | static decode(reader, position) {
  method decodeText (line 896) | static decodeText(reader, json) {
  method decode (line 911) | static decode(reader, position) {
  method decodeText (line 921) | static decodeText(reader, json) {
  method decode (line 934) | static decode(reader, position) {
  method decodeText (line 945) | static decodeText(reader, json) {
  method decode (line 959) | static decode(reader, position) {
  method decodeText (line 966) | static decodeText(reader, json) {
  method decode (line 976) | static decode(reader, position) {
  method decodeText (line 984) | static decodeText(reader, json) {
  method decode (line 995) | static decode(reader, position) {
  method decodeText (line 1001) | static decodeText(reader, json) {
  method decode (line 1010) | static decode(reader, position) {
  method decodeText (line 1016) | static decodeText(reader, json) {
  method decode (line 1042) | static decode(reader, position) {
  method decodeText (line 1049) | static decodeText(reader, json) {
  method decode (line 1059) | static decode(reader, position) {
  method decodeText (line 1065) | static decodeText(reader, json) {
  method decode (line 1074) | static decode(reader, position) {
  method decodeText (line 1082) | static decodeText(reader, json) {
  method decode (line 1093) | static decode(reader, position) {
  method decodeText (line 1099) | static decodeText(reader, json) {
  method decode (line 1108) | static decode(reader, position) {
  method decodeText (line 1119) | static decodeText(reader, json) {
  method decode (line 1133) | static decode(reader, position) {
  method decodeText (line 1140) | static decodeText(reader, json) {
  method decode (line 1150) | static decode(reader, position) {
  method decodeText (line 1158) | static decodeText(reader, json) {
  method decode (line 1169) | static decode(reader, position) {
  method decodeText (line 1191) | static decodeText(reader, json) {
  method decode (line 1216) | static decode(reader, position) {
  method decodeText (line 1228) | static decodeText(reader, json) {
  method decode (line 1243) | static decode(reader, position) {
  method decodeText (line 1249) | static decodeText(reader, json) {
  method decode (line 1264) | static decode(reader, position) {
  method decodeText (line 1270) | static decodeText(reader, json) {
  method decode (line 1293) | static decode(reader, position) {
  method decodeText (line 1305) | static decodeText(reader, json) {
  method decode (line 1320) | static decode(reader, position) {
  method decodeText (line 1333) | static decodeText(reader, json) {
  method decode (line 1349) | static decode(reader, position) {
  method decodeText (line 1360) | static decodeText(reader, json) {
  method decode (line 1374) | static decode(reader, position) {
  method decodeText (line 1386) | static decodeText(reader, json) {
  method decode (line 1401) | static decode(reader, position) {
  method decodeText (line 1409) | static decodeText(reader, json) {
  method decode (line 1426) | static decode(reader, position) {
  method decodeText (line 1432) | static decodeText(reader, json) {
  method decode (line 1441) | static decode(reader, position) {
  method decodeText (line 1449) | static decodeText(reader, json) {
  method decode (line 1460) | static decode(reader, position) {
  method decodeText (line 1467) | static decodeText(reader, json) {
  method decode (line 1477) | static decode(reader, position) {
  method decodeText (line 1485) | static decodeText(reader, json) {
  method decode (line 1496) | static decode(reader, position) {
  method decodeText (line 1505) | static decodeText(reader, json) {
  method decode (line 1523) | static decode(reader, position) {
  method decodeText (line 1533) | static decodeText(reader, json) {
  method decode (line 1546) | static decode(reader, position) {
  method decodeText (line 1552) | static decodeText(reader, json) {
  method decode (line 1561) | static decode(reader, position) {
  method decodeText (line 1568) | static decodeText(reader, json) {
  method decode (line 1578) | static decode(reader, position) {
  method decodeText (line 1585) | static decodeText(reader, json) {
  method decode (line 1595) | static decode(reader, position) {
  method decodeText (line 1601) | static decodeText(reader, json) {
  method decode (line 1610) | static decode(reader, position) {
  method decodeText (line 1616) | static decodeText(reader, json) {
  method decode (line 1625) | static decode(reader, position) {
  method decodeText (line 1634) | static decodeText(reader, json) {
  method decode (line 1651) | static decode(reader, position) {
  method decodeText (line 1661) | static decodeText(reader, json) {
  method decode (line 1674) | static decode(reader, position) {
  method decodeText (line 1685) | static decodeText(reader, json) {
  method decode (line 1699) | static decode(reader, position) {
  method decodeText (line 1710) | static decodeText(reader, json) {
  method decode (line 1724) | static decode(reader, position) {
  method decodeText (line 1733) | static decodeText(reader, json) {
  method decode (line 1745) | static decode(reader, position) {
  method decodeText (line 1752) | static decodeText(reader, json) {
  method decode (line 1762) | static decode(reader, position) {
  method decodeText (line 1768) | static decodeText(reader, json) {
  method decode (line 1777) | static decode(/* reader, position */) {
  method decodeText (line 1782) | static decodeText(/* reader, json */) {
  method decode (line 1790) | static decode(/* reader, position */) {
  method decodeText (line 1795) | static decodeText(/* reader, json */) {
  method decode (line 1803) | static decode(reader, position) {
  method decodeText (line 1809) | static decodeText(reader, json) {
  method decode (line 1818) | static decode(/* reader, position */) {
  method decodeText (line 1823) | static decodeText(/* reader, json */) {
  method decode (line 1831) | static decode(/* reader, position */) {
  method decodeText (line 1836) | static decodeText(/* reader, json */) {
  method decode (line 1844) | static decode(reader, position) {
  method decodeText (line 1852) | static decodeText(reader, json) {
  method decode (line 1863) | static decode(reader, position) {
  method decodeText (line 1869) | static decodeText(reader, json) {
  method decode (line 1878) | static decode(reader, position) {
  method decodeText (line 1884) | static decodeText(reader, json) {
  method decode (line 1893) | static decode(reader, position) {
  method decodeText (line 1900) | static decodeText(reader, json) {
  method decode (line 1910) | static decode(reader, position) {
  method decodeText (line 1916) | static decodeText(reader, json) {
  method decode (line 1925) | static decode(/* reader, position */) {
  method decodeText (line 1930) | static decodeText(/* reader, json */) {
  method decode (line 1944) | static decode(reader, position) {
  method decodeText (line 1950) | static decodeText(reader, json) {
  method decode (line 1959) | static decode(reader, position) {
  method decodeText (line 1966) | static decodeText(reader, json) {
  method decode (line 1976) | static decode(/* reader, position */) {
  method decodeText (line 1981) | static decodeText(/* reader, json */) {
  method decode (line 1989) | static decode(/* reader, position */) {
  method decodeText (line 1994) | static decodeText(/* reader, json */) {
  method decode (line 2002) | static decode(/* reader, position */) {
  method decodeText (line 2007) | static decodeText(/* reader, json */) {
  method decode (line 2015) | static decode(reader, position) {
  method decodeText (line 2021) | static decodeText(reader, json) {
  method decode (line 2030) | static decode(reader, position) {
  method decodeText (line 2036) | static decodeText(reader, json) {
  method decode (line 2045) | static decode(reader, position) {
  method decodeText (line 2051) | static decodeText(reader, json) {
  method decode (line 2060) | static decode(reader, position) {
  method decodeText (line 2066) | static decodeText(reader, json) {
  method decode (line 2075) | static decode(reader, position) {
  method decodeText (line 2086) | static decodeText(reader, json) {
  method decode (line 2100) | static decode(/* reader, position */) {
  method decodeText (line 2105) | static decodeText(/* reader, json */) {
  method decode (line 2113) | static decode(reader, position) {
  method decodeText (line 2120) | static decodeText(reader, json) {
  method decode (line 2130) | static decode(/* reader, position */) {
  method decodeText (line 2135) | static decodeText(/* reader, json */) {
  method decode (line 2143) | static decode(/* reader, position */) {
  method decodeText (line 2148) | static decodeText(/* reader, json */) {
  method decode (line 2156) | static decode(/* reader, position */) {
  method decodeText (line 2161) | static decodeText(/* reader, json */) {
  method decode (line 2169) | static decode(reader, position) {
  method decodeText (line 2175) | static decodeText(reader, json) {
  method decode (line 2184) | static decode(reader, position) {
  method decodeText (line 2190) | static decodeText(reader, json) {
  method decode (line 2199) | static decode(/* reader, position */) {
  method decodeText (line 2204) | static decodeText(/* reader, json */) {
  method decode (line 2212) | static decode(/* reader, position */) {
  method decodeText (line 2217) | static decodeText(/* reader, json */) {
  method decode (line 2225) | static decode(/* reader, position */) {
  method decodeText (line 2230) | static decodeText(/* reader, json */) {
  method decode (line 2238) | static decode(/* reader, position */) {
  method decodeText (line 2243) | static decodeText(/* reader, json */) {
  method decode (line 2251) | static decode(/* reader, position */) {
  method decodeText (line 2256) | static decodeText(/* reader, json */) {
  method decode (line 2264) | static decode(/* reader, position */) {
  method decodeText (line 2269) | static decodeText(/* reader, json */) {
  method decode (line 2277) | static decode(/* reader, position */) {
  method decodeText (line 2282) | static decodeText(/* reader, json */) {
  method decode (line 2290) | static decode(reader, position) {
  method decodeText (line 2300) | static decodeText(reader, json) {
  method decode (line 2313) | static decode(/* reader, position */) {
  method decodeText (line 2318) | static decodeText(/* reader, json */) {
  method decode (line 2326) | static decode(reader, position) {
  method decodeText (line 2332) | static decodeText(reader, json) {
  method decode (line 2341) | static decode(/* reader, position */) {
  method decodeText (line 2346) | static decodeText(/* reader, json */) {
  method decode (line 2354) | static decode(/* reader, position */) {
  method decodeText (line 2359) | static decodeText(/* reader, json */) {
  method decode (line 2367) | static decode(reader, position) {
  method decodeText (line 2373) | static decodeText(reader, json) {
  method decode (line 2382) | static decode(/* reader, position */) {
  method decodeText (line 2387) | static decodeText(/* reader, json */) {
  method decode (line 2395) | static decode(/* reader, position */) {
  method decodeText (line 2400) | static decodeText(/* reader, json */) {
  method decode (line 2408) | static decode(reader, position) {
  method decodeText (line 2417) | static decodeText(reader, json) {
  method decode (line 2429) | static decode(reader, position) {
  method decodeText (line 2436) | static decodeText(reader, json) {
  method decode (line 2446) | static decode(/* reader, position */) {
  method decodeText (line 2451) | static decodeText(/* reader, json */) {
  method decode (line 2459) | static decode(reader, position) {
  method decodeText (line 2465) | static decodeText(reader, json) {
  method decode (line 2474) | static decode(/* reader, position */) {
  method decodeText (line 2479) | static decodeText(/* reader, json */) {
  method decode (line 2487) | static decode(/* reader, position */) {
  method decodeText (line 2492) | static decodeText(/* reader, json */) {
  method decode (line 2500) | static decode(/* reader, position */) {
  method decodeText (line 2505) | static decodeText(/* reader, json */) {
  method decode (line 2513) | static decode(/* reader, position */) {
  method decodeText (line 2518) | static decodeText(/* reader, json */) {
  method decode (line 2526) | static decode(reader, position) {
  method decodeText (line 2533) | static decodeText(reader, json) {
  method decode (line 2543) | static decode(/* reader, position */) {
  method decodeText (line 2548) | static decodeText(/* reader, json */) {
  method decode (line 2556) | static decode(/* reader, position */) {
  method decodeText (line 2561) | static decodeText(/* reader, json */) {
  method decode (line 2569) | static decode(/* reader, position */) {
  method decodeText (line 2574) | static decodeText(/* reader, json */) {
  method decode (line 2582) | static decode(/* reader, position */) {
  method decodeText (line 2587) | static decodeText(/* reader, json */) {
  method decode (line 2595) | static decode(/* reader, position */) {
  method decodeText (line 2600) | static decodeText(/* reader, json */) {
  method decode (line 2608) | static decode(/* reader, position */) {
  method decodeText (line 2613) | static decodeText(/* reader, json */) {
  method decode (line 2621) | static decode(reader, position) {
  method decodeText (line 2627) | static decodeText(reader, json) {
  method decode (line 2636) | static decode(/* reader, position */) {
  method decodeText (line 2641) | static decodeText(/* reader, json */) {
  method decode (line 2654) | static decode(reader, position) {
  method decodeText (line 2660) | static decodeText(reader, json) {
  method decode (line 2669) | static decode(reader, position) {
  method decodeText (line 2675) | static decodeText(reader, json) {
  method decode (line 2684) | static decode(/* reader, position */) {
  method decodeText (line 2689) | static decodeText(/* reader, json */) {
  method decode (line 2697) | static decode(/* reader, position */) {
  method decodeText (line 2702) | static decodeText(/* reader, json */) {
  method decode (line 2710) | static decode(/* reader, position */) {
  method decodeText (line 2715) | static decodeText(/* reader, json */) {
  method decode (line 2723) | static decode(/* reader, position */) {
  method decodeText (line 2728) | static decodeText(/* reader, json */) {
  method decode (line 2736) | static decode(reader, position) {
  method decodeText (line 2743) | static decodeText(reader, json) {
  method decode (line 2753) | static decode(/* reader, position */) {
  method decodeText (line 2758) | static decodeText(/* reader, json */) {
  method decode (line 2766) | static decode(/* reader, position */) {
  method decodeText (line 2771) | static decodeText(/* reader, json */) {
  method decode (line 2779) | static decode(/* reader, position */) {
  method decodeText (line 2784) | static decodeText(/* reader, json */) {
  method decode (line 2792) | static decode(reader, position) {
  method decodeText (line 2799) | static decodeText(reader, json) {
  method decode (line 2809) | static decode(reader, position) {
  method decodeText (line 2815) | static decodeText(reader, json) {
  method decode (line 2824) | static decode(reader, position) {
  method decodeText (line 2831) | static decodeText(reader, json) {
  method decode (line 2841) | static decode(/* reader, position */) {
  method decodeText (line 2846) | static decodeText(/* reader, json */) {
  method decode (line 2854) | static decode(/* reader, position */) {
  method decodeText (line 2859) | static decodeText(/* reader, json */) {
  method decode (line 2867) | static decode(/* reader, position */) {
  method decodeText (line 2872) | static decodeText(/* reader, json */) {
  method decode (line 2880) | static decode(/* reader, position */) {
  method decodeText (line 2885) | static decodeText(/* reader, json */) {
  method decode (line 2893) | static decode(/* reader, position */) {
  method decodeText (line 2898) | static decodeText(/* reader, json */) {
  method decode (line 2906) | static decode(/* reader, position */) {
  method decodeText (line 2911) | static decodeText(/* reader, json */) {
  method decode (line 2919) | static decode(reader, position) {
  method decodeText (line 2927) | static decodeText(reader, json) {
  method decode (line 2938) | static decode(reader, position) {
  method decodeText (line 2945) | static decodeText(reader, json) {
  method decode (line 2955) | static decode(/* reader, position */) {
  method decodeText (line 2960) | static decodeText(/* reader, json */) {
  method decode (line 2968) | static decode(/* reader, position */) {
  method decodeText (line 2973) | static decodeText(/* reader, json */) {
  method decode (line 2981) | static decode(reader, position) {
  method decodeText (line 2989) | static decodeText(reader, json) {
  method decode (line 3000) | static decode(/* reader, position */) {
  method decodeText (line 3005) | static decodeText(/* reader, json */) {
  method decode (line 3013) | static decode(/* reader, position */) {
  method decodeText (line 3018) | static decodeText(/* reader, json */) {
  method decode (line 3026) | static decode(/* reader, position */) {
  method decodeText (line 3031) | static decodeText(/* reader, json */) {
  method decode (line 3039) | static decode(reader, position) {
  method decodeText (line 3046) | static decodeText(reader, json) {
  method decode (line 3056) | static decode(/* reader, position */) {
  method decodeText (line 3061) | static decodeText(/* reader, json */) {
  method decode (line 3069) | static decode(/* reader, position */) {
  method decodeText (line 3074) | static decodeText(/* reader, json */) {
  method decode (line 3082) | static decode(reader, position) {
  method decodeText (line 3089) | static decodeText(reader, json) {
  method decode (line 3099) | static decode(reader, position) {
  method decodeText (line 3105) | static decodeText(reader, json) {
  method decode (line 3114) | static decode(reader, position) {
  method decodeText (line 3120) | static decodeText(reader, json) {
  method decode (line 3129) | static decode(/* reader, position */) {
  method decodeText (line 3134) | static decodeText(/* reader, json */) {
  method decode (line 3142) | static decode(/* reader, position */) {
  method decodeText (line 3147) | static decodeText(/* reader, json */) {
  method decode (line 3155) | static decode(/* reader, position */) {
  method decodeText (line 3160) | static decodeText(/* reader, json */) {
  method decode (line 3168) | static decode(/* reader, position */) {
  method decodeText (line 3173) | static decodeText(/* reader, json */) {
  method decode (line 3181) | static decode(/* reader, position */) {
  method decodeText (line 3186) | static decodeText(/* reader, json */) {
  method decode (line 3194) | static decode(/* reader, position */) {
  method decodeText (line 3199) | static decodeText(/* reader, json */) {
  method decode (line 3207) | static decode(/* reader, position */) {
  method decodeText (line 3212) | static decodeText(/* reader, json */) {
  method decode (line 3220) | static decode(/* reader, position */) {
  method decodeText (line 3225) | static decodeText(/* reader, json */) {
  method decode (line 3233) | static decode(/* reader, position */) {
  method decodeText (line 3238) | static decodeText(/* reader, json */) {
  method decode (line 3246) | static decode(/* reader, position */) {
  method decodeText (line 3251) | static decodeText(/* reader, json */) {
  method decode (line 3259) | static decode(/* reader, position */) {
  method decodeText (line 3264) | static decodeText(/* reader, json */) {
  method decode (line 3282) | static decode(reader, position) {
  method decodeText (line 3288) | static decodeText(reader, json) {
  method decode (line 3297) | static decode(reader, position) {
  method decodeText (line 3305) | static decodeText(reader, json) {
  method decode (line 3316) | static decode(reader, position) {
  method decodeText (line 3323) | static decodeText(reader, json) {
  method decode (line 3333) | static decode(reader, position) {
  method decodeText (line 3340) | static decodeText(reader, json) {
  method decode (line 3350) | static decode(reader, position) {
  method decodeText (line 3357) | static decodeText(reader, json) {
  method decode (line 3367) | static decode(reader, position) {
  method decodeText (line 3373) | static decodeText(reader, json) {
  method decode (line 3387) | static decode(reader, position) {
  method decodeText (line 3393) | static decodeText(reader, json) {
  method decode (line 3402) | static decode(reader, position) {
  method decodeText (line 3409) | static decodeText(reader, json) {
  method decode (line 3419) | static decode(/* reader, position */) {
  method decodeText (line 3424) | static decodeText(/* reader, json */) {
  method decode (line 3432) | static decode(reader, position) {
  method decodeText (line 3441) | static decodeText(reader, json) {
  method decode (line 3462) | static decode(reader, position) {
  method decodeText (line 3472) | static decodeText(reader, json) {
  method decode (line 3485) | static decode(/* reader, position */) {
  method decodeText (line 3490) | static decodeText(/* reader, json */) {
  method decode (line 3498) | static decode(reader, position) {
  method decodeText (line 3515) | static decodeText(reader, json) {
  method decode (line 3535) | static decode(reader, position) {
  method decodeText (line 3547) | static decodeText(reader, json) {
  method decode (line 3562) | static decode(reader, position) {
  method decodeText (line 3570) | static decodeText(reader, json) {
  method decode (line 3581) | static decode(reader, position) {
  method decodeText (line 3588) | static decodeText(reader, json) {
  method decode (line 3598) | static decode(reader, position) {
  method decodeText (line 3605) | static decodeText(reader, json) {
  method decode (line 3615) | static decode(reader, position) {
  method decodeText (line 3625) | static decodeText(reader, json) {
  method identifier (line 3638) | static identifier(reader) {
  method create (line 3642) | static create(reader) {
  method createText (line 3646) | static createText(reader) {
  method decode (line 3650) | static decode(reader, position) {
  method decodeText (line 3663) | static decodeText(reader, json) {

FILE: source/circle.js
  method match (line 10) | async match(context) {
  method open (line 22) | async open(context) {
  method constructor (line 71) | constructor(metadata, model, stream) {
  method constructor (line 167) | constructor(metadata, subgraph, signatures, subgraphMetadata, name, oper...
  method constructor (line 257) | constructor(signature, tensors) {
  method constructor (line 274) | constructor(metadata, node, type, identifier, tensors) {
  method constructor (line 407) | constructor(name, value, type = null, visible = true) {
  method constructor (line 417) | constructor(index, tensor, initializer, description, denotation) {
  method constructor (line 440) | constructor(index, tensor, buffer, stream, is_variable) {
  method values (line 458) | get values() {
  method constructor (line 494) | constructor(tensor, denotation) {
  method toString (line 508) | toString() {
  method constructor (line 515) | constructor(dimensions) {
  method toString (line 519) | toString() {
  method constructor (line 529) | constructor(message) {

FILE: source/cntk-proto.js
  constant CNTK (line 2) | const CNTK = {};
  method constructor (line 8) | constructor() {
  method decode (line 12) | static decode(reader, length) {
  method decode (line 32) | static decode(reader, length) {
  method values (line 62) | get values() {
  method decode (line 67) | static decode(reader, length) {
  method constructor (line 124) | constructor() {
  method decode (line 128) | static decode(reader, length) {
  method constructor (line 148) | constructor() {
  method decode (line 152) | static decode(reader, length) {
  method decode (line 172) | static decode(reader, length) {
  method constructor (line 194) | constructor() {
  method decode (line 198) | static decode(reader, length) {
  method constructor (line 218) | constructor() {
  method decode (line 222) | static decode(reader, length) {
  method constructor (line 242) | constructor() {
  method decode (line 246) | static decode(reader, length) {
  method value (line 271) | get value() {
  method decode (line 276) | static decode(reader, length) {

FILE: source/cntk.js
  method match (line 6) | async match(context) {
  method open (line 21) | async open(context) {
  method _convertDictionary (line 56) | static _convertDictionary(dictionary) {
  method _convertDictionaryValue (line 64) | static _convertDictionaryValue(dictionaryValue) {
  method _convertVectorValue (line 93) | static _convertVectorValue(vectorValue) {
  method constructor (line 102) | constructor(metadata, version, obj) {
  method constructor (line 119) | constructor(metadata, version, obj) {
  method constructor (line 233) | constructor(name, value, type = null, visible = true) {
  method constructor (line 243) | constructor(version, obj) {
  method constructor (line 285) | constructor(metadata, version, obj, values) {
  method constructor (line 432) | constructor(version, tensor) {
  method constructor (line 460) | constructor(version, dataType, shape) {
  method toString (line 485) | toString() {
  method constructor (line 492) | constructor(version, shape) {
  method toString (line 505) | toString() {
  method constructor (line 512) | constructor(name, nodes, inputs, outputs) {
  method constructor (line 550) | constructor(metadata) {
  method add (line 556) | add(name, func) {
  method name (line 563) | name(code) {
  method type (line 568) | type(name) {
  method attribute (line 575) | attribute(type, name) {
  method constructor (line 594) | constructor(reader) {
  method constructor (line 962) | constructor(reader) {
  method position (line 966) | get position() {
  method seek (line 970) | seek(offset) {
  method skip (line 974) | skip(offset) {
  method read (line 978) | read(length) {
  method boolean (line 982) | boolean() {
  method byte (line 986) | byte() {
  method int32 (line 990) | int32() {
  method uint16 (line 994) | uint16() {
  method uint32 (line 998) | uint32() {
  method uint64 (line 1002) | uint64() {
  method float32 (line 1006) | float32() {
  method float64 (line 1010) | float64() {
  method match (line 1014) | match(text) {
  method assert (line 1029) | assert(text) {
  method string (line 1035) | string() {
  method strings (line 1045) | strings() {
  method booleans (line 1054) | booleans() {
  method matrix (line 1063) | matrix() {
  method shape (line 1086) | shape(acceptLegacyFormat) {
  method constructor (line 1123) | constructor(message) {

FILE: source/coreml-proto.js
  method constructor (line 8) | constructor() {
  method decode (line 13) | static decode(reader, length) {
  method decodeText (line 33) | static decodeText(reader) {
  method decode (line 56) | static decode(reader, length) {
  method decodeText (line 73) | static decodeText(reader) {
  method decode (line 95) | static decode(reader, length) {
  method decodeText (line 112) | static decodeText(reader) {
  method decode (line 134) | static decode(reader, length) {
  method decodeText (line 157) | static decodeText(reader) {
  method constructor (line 187) | constructor() {
  method decode (line 191) | static decode(reader, length) {
  method decodeText (line 220) | static decodeText(reader) {
  method constructor (line 257) | constructor() {
  method decode (line 263) | static decode(reader, length) {
  method decodeText (line 295) | static decodeText(reader) {
  method constructor (line 334) | constructor() {
  method decode (line 342) | static decode(reader, length) {
  method decodeText (line 383) | static decodeText(reader) {
  method decode (line 432) | static decode(reader, length) {
  method decodeText (line 452) | static decodeText(reader) {
  method Type (line 478) | get Type() {
  method decode (line 483) | static decode(reader, length) {
  method decodeText (line 617) | static decodeText(reader) {
  method VisionFeaturePrintType (line 760) | get VisionFeaturePrintType() {
  method decode (line 765) | static decode(reader, length) {
  method decodeText (line 785) | static decodeText(reader) {
  method decode (line 808) | static decode(reader, length) {
  method decodeText (line 825) | static decodeText(reader) {
  method constructor (line 853) | constructor() {
  method decode (line 857) | static decode(reader, length) {
  method decodeText (line 877) | static decodeText(reader) {
  method AudioFeaturePrintType (line 907) | get AudioFeaturePrintType() {
  method decode (line 912) | static decode(reader, length) {
  method decodeText (line 929) | static decodeText(reader) {
  method decode (line 949) | static decode(reader, length) {
  method decodeText (line 966) | static decodeText(reader) {
  method ClassLabels (line 993) | get ClassLabels() {
  method decode (line 998) | static decode(reader, length) {
  method decodeText (line 1024) | static decodeText(reader) {
  method Tags (line 1057) | get Tags() {
  method decode (line 1062) | static decode(reader, length) {
  method decodeText (line 1100) | static decodeText(reader) {
  method ClassLabels (line 1149) | get ClassLabels() {
  method decode (line 1154) | static decode(reader, length) {
  method decodeText (line 1180) | static decodeText(reader) {
  method decode (line 1213) | static decode(reader, length) {
  method decodeText (line 1236) | static decodeText(reader) {
  method SoundAnalysisPreprocessingType (line 1266) | get SoundAnalysisPreprocessingType() {
  method decode (line 1271) | static decode(reader, length) {
  method decodeText (line 1288) | static decodeText(reader) {
  method decode (line 1308) | static decode(reader, length) {
  method decodeText (line 1322) | static decodeText(reader) {
  method constructor (line 1339) | constructor() {
  method decode (line 1343) | static decode(reader, length) {
  method decodeText (line 1360) | static decodeText(reader) {
  method constructor (line 1380) | constructor() {
  method decode (line 1384) | static decode(reader, length) {
  method decodeText (line 1401) | static decodeText(reader) {
  method constructor (line 1421) | constructor() {
  method decode (line 1425) | static decode(reader, length) {
  method decodeText (line 1442) | static decodeText(reader) {
  method constructor (line 1462) | constructor() {
  method decode (line 1466) | static decode(reader, length) {
  method decodeText (line 1483) | static decodeText(reader) {
  method constructor (line 1503) | constructor() {
  method decode (line 1507) | static decode(reader, length) {
  method decodeText (line 1524) | static decodeText(reader) {
  method constructor (line 1544) | constructor() {
  method decode (line 1548) | static decode(reader, length) {
  method decodeText (line 1565) | static decodeText(reader) {
  method constructor (line 1585) | constructor() {
  method decode (line 1589) | static decode(reader, length) {
  method decodeText (line 1606) | static decodeText(reader) {
  method constructor (line 1626) | constructor() {
  method decode (line 1630) | static decode(reader, length) {
  method decodeText (line 1647) | static decodeText(reader) {
  method decode (line 1667) | static decode(reader, length) {
  method decodeText (line 1687) | static decodeText(reader) {
  method constructor (line 1713) | constructor() {
  method decode (line 1717) | static decode(reader, length) {
  method decodeText (line 1734) | static decodeText(reader) {
  method decode (line 1754) | static decode(reader, length) {
  method decodeText (line 1774) | static decodeText(reader) {
  method decode (line 1800) | static decode(reader, length) {
  method decodeText (line 1826) | static decodeText(reader) {
  method decode (line 1860) | static decode(reader, length) {
  method decodeText (line 1874) | static decodeText(reader) {
  method decode (line 1891) | static decode(reader, length) {
  method decodeText (line 1905) | static decodeText(reader) {
  method decode (line 1922) | static decode(reader, length) {
  method decodeText (line 1936) | static decodeText(reader) {
  method decode (line 1953) | static decode(reader, length) {
  method decodeText (line 1973) | static decodeText(reader) {
  method SizeFlexibility (line 1999) | get SizeFlexibility() {
  method decode (line 2004) | static decode(reader, length) {
  method decodeText (line 2033) | static decodeText(reader) {
  method decode (line 2077) | static decode(reader, length) {
  method decodeText (line 2097) | static decodeText(reader) {
  method constructor (line 2123) | constructor() {
  method decode (line 2127) | static decode(reader, length) {
  method decodeText (line 2144) | static decodeText(reader) {
  method decode (line 2164) | static decode(reader, length) {
  method decodeText (line 2184) | static decodeText(reader) {
  method constructor (line 2210) | constructor() {
  method ShapeFlexibility (line 2214) | get ShapeFlexibility() {
  method defaultOptionalValue (line 2219) | get defaultOptionalValue() {
  method decode (line 2224) | static decode(reader, length) {
  method decodeText (line 2259) | static decodeText(reader) {
  method constructor (line 2308) | constructor() {
  method decode (line 2312) | static decode(reader, length) {
  method decodeText (line 2329) | static decodeText(reader) {
  method constructor (line 2349) | constructor() {
  method decode (line 2353) | static decode(reader, length) {
  method decodeText (line 2370) | static decodeText(reader) {
  method constructor (line 2390) | constructor() {
  method decode (line 2394) | static decode(reader, length) {
  method decodeText (line 2411) | static decodeText(reader) {
  method KeyType (line 2431) | get KeyType() {
  method decode (line 2436) | static decode(reader, length) {
  method decodeText (line 2456) | static decodeText(reader) {
  method Type (line 2479) | get Type() {
  method decode (line 2484) | static decode(reader, length) {
  method decodeText (line 2507) | static decodeText(reader) {
  method Type (line 2535) | get Type() {
  method decode (line 2540) | static decode(reader, length) {
  method decodeText (line 2557) | static decodeText(reader) {
  method Type (line 2577) | get Type() {
  method decode (line 2582) | static decode(reader, length) {
  method decodeText (line 2623) | static decodeText(reader) {
  method constructor (line 2669) | constructor() {
  method decode (line 2673) | static decode(reader, length) {
  method decodeText (line 2690) | static decodeText(reader) {
  method constructor (line 2710) | constructor() {
  method decode (line 2714) | static decode(reader, length) {
  method decodeText (line 2761) | static decodeText(reader) {
  method decode (line 2822) | static decode(reader, length) {
  method decodeText (line 2842) | static decodeText(reader) {
  method decode (line 2868) | static decode(reader, length) {
  method decodeText (line 2888) | static decodeText(reader) {
  method constructor (line 2914) | constructor() {
  method decode (line 2918) | static decode(reader, length) {
  method decodeText (line 2938) | static decodeText(reader) {
  method MappingType (line 2963) | get MappingType() {
  method ValueOnUnknown (line 2968) | get ValueOnUnknown() {
  method decode (line 2973) | static decode(reader, length) {
  method decodeText (line 2999) | static decodeText(reader) {
  method constructor (line 3028) | constructor() {
  method decode (line 3032) | static decode(reader, length) {
  method decodeText (line 3055) | static decodeText(reader) {
  method value (line 3084) | get value() {
  method decode (line 3089) | static decode(reader, length) {
  method decodeText (line 3121) | static decodeText(reader) {
  method Map (line 3156) | get Map() {
  method decode (line 3161) | static decode(reader, length) {
  method decodeText (line 3181) | static decodeText(reader) {
  method constructor (line 3204) | constructor() {
  method decode (line 3208) | static decode(reader, length) {
  method decodeText (line 3225) | static decodeText(reader) {
  method decode (line 3245) | static decode(reader, length) {
  method decodeText (line 3265) | static decodeText(reader) {
  method constructor (line 3291) | constructor() {
  method decode (line 3296) | static decode(reader, length) {
  method decodeText (line 3319) | static decodeText(reader) {
  method constructor (line 3347) | constructor() {
  method decode (line 3351) | static decode(reader, length) {
  method decodeText (line 3368) | static decodeText(reader) {
  method constructor (line 3394) | constructor() {
  method ClassLabels (line 3399) | get ClassLabels() {
  method decode (line 3404) | static decode(reader, length) {
  method decodeText (line 3436) | static decodeText(reader) {
  method constructor (line 3474) | constructor() {
  method decode (line 3478) | static decode(reader, length) {
  method decodeText (line 3495) | static decodeText(reader) {
  method ClassLabels (line 3525) | get ClassLabels() {
  method DefaultClassLabel (line 3530) | get DefaultClassLabel() {
  method WeightingScheme (line 3535) | get WeightingScheme() {
  method decode (line 3540) | static decode(reader, length) {
  method decodeText (line 3578) | static decodeText(reader) {
  method constructor (line 3622) | constructor() {
  method IndexType (line 3626) | get IndexType() {
  method DistanceFunction (line 3631) | get DistanceFunction() {
  method decode (line 3636) | static decode(reader, length) {
  method decodeText (line 3665) | static decodeText(reader) {
  method decode (line 3699) | static decode(reader, length) {
  method decodeText (line 3713) | static decodeText(reader) {
  method decode (line 3730) | static decode(reader, length) {
  method decodeText (line 3744) | static decodeText(reader) {
  method decode (line 3761) | static decode(reader, length) {
  method decodeText (line 3775) | static decodeText(reader) {
  method decode (line 3792) | static decode(reader, length) {
  method decodeText (line 3809) | static decodeText(reader) {
  method decode (line 3831) | static decode(reader, length) {
  method decodeText (line 3845) | static decodeText(reader) {
  method AllowedValues (line 3862) | get AllowedValues() {
  method decode (line 3867) | static decode(reader, length) {
  method decodeText (line 3890) | static decodeText(reader) {
  method AllowedValues (line 3918) | get AllowedValues() {
  method decode (line 3923) | static decode(reader, length) {
  method decodeText (line 3943) | static decodeText(reader) {
  method decode (line 3968) | static decode(reader, length) {
  method decodeText (line 3985) | static decodeText(reader) {
  method decode (line 4007) | static decode(reader, length) {
  method decodeText (line 4024) | static decodeText(reader) {
  method decode (line 4046) | static decode(reader, length) {
  method decodeText (line 4060) | static decodeText(reader) {
  method ImputedValue (line 4077) | get ImputedValue() {
  method ReplaceValue (line 4082) | get ReplaceValue() {
  method decode (line 4087) | static decode(reader, length) {
  method decodeText (line 4131) | static decodeText(reader) {
  method constructor (line 4180) | constructor() {
  method decode (line 4185) | static decode(reader, length) {
  method decodeText (line 4211) | static decodeText(reader) {
  method constructor (line 4243) | constructor() {
  method decode (line 4249) | static decode(reader, length) {
  method decodeText (line 4275) | static decodeText(reader) {
  method constructor (line 4306) | constructor() {
  method decode (line 4313) | static decode(reader, length) {
  method decodeText (line 4339) | static decodeText(reader) {
  method constructor (line 4368) | constructor() {
  method decode (line 4372) | static decode(reader, length) {
  method decodeText (line 4389) | static decodeText(reader) {
  method binding (line 4409) | get binding() {
  method decode (line 4414) | static decode(reader, length) {
  method decodeText (line 4434) | static decodeText(reader) {
  method constructor (line 4457) | constructor() {
  method decode (line 4464) | static decode(reader, length) {
  method decodeText (line 4493) | static decodeText(reader) {
  method decode (line 4527) | static decode(reader, length) {
  method decodeText (line 4547) | static decodeText(reader) {
  method type (line 4573) | get type() {
  method decode (line 4578) | static decode(reader, length) {
  method decodeText (line 4607) | static decodeText(reader) {
  method constructor (line 4665) | constructor() {
  method decode (line 4670) | static decode(reader, length) {
  method decodeText (line 4696) | static decodeText(reader) {
  method constructor (line 4728) | constructor() {
  method decode (line 4732) | static decode(reader, length) {
  method decodeText (line 4749) | static decodeText(reader) {
  method decode (line 4769) | static decode(reader, length) {
  method decodeText (line 4789) | static decodeText(reader) {
  method decode (line 4815) | static decode(reader, length) {
  method decodeText (line 4835) | static decodeText(reader) {
  method decode (line 4861) | static decode(reader, length) {
  method decodeText (line 4878) | static decodeText(reader) {
  method dimension (line 4900) | get dimension() {
  method decode (line 4905) | static decode(reader, length) {
  method decodeText (line 4925) | static decodeText(reader) {
  method decode (line 4948) | static decode(reader, length) {
  method decodeText (line 4965) | static decodeText(reader) {
  method decode (line 4987) | static decode(reader, length) {
  method decodeText (line 5004) | static decodeText(reader) {
  method value (line 5026) | get value() {
  method decode (line 5031) | static decode(reader, length) {
  method decodeText (line 5057) | static decodeText(reader) {
  method value (line 5089) | get value() {
  method decode (line 5094) | static decode(reader, length) {
  method decodeText (line 5120) | static decodeText(reader) {
  method decode (line 5149) | static decode(reader, length) {
  method decodeText (line 5169) | static decodeText(reader) {
  method value (line 5195) | get value() {
  method decode (line 5200) | static decode(reader, length) {
  method decodeText (line 5235) | static decodeText(reader) {
  method constructor (line 5273) | constructor() {
  method decode (line 5277) | static decode(reader, length) {
  method decodeText (line 5294) | static decodeText(reader) {
  method constructor (line 5314) | constructor() {
  method decode (line 5318) | static decode(reader, length) {
  method decodeText (line 5335) | static decodeText(reader) {
  method constructor (line 5355) | constructor() {
  method decode (line 5359) | static decode(reader, length) {
  method decodeText (line 5376) | static decodeText(reader) {
  method constructor (line 5396) | constructor() {
  method decode (line 5400) | static decode(reader, length) {
  method decodeText (line 5417) | static decodeText(reader) {
  method constructor (line 5437) | constructor() {
  method decode (line 5441) | static decode(reader, length) {
  method decodeText (line 5458) | static decodeText(reader) {
  method constructor (line 5478) | constructor() {
  method decode (line 5482) | static decode(reader, length) {
  method decodeText (line 5499) | static decodeText(reader) {
  method decode (line 5519) | static decode(reader, length) {
  method decodeText (line 5536) | static decodeText(reader) {
  method constructor (line 5558) | constructor() {
  method decode (line 5562) | static decode(reader, length) {
  method decodeText (line 5579) | static decodeText(reader) {
  method constructor (line 5599) | constructor() {
  method decode (line 5603) | static decode(reader, length) {
  method decodeText (line 5620) | static decodeText(reader) {
  method constructor (line 5640) | constructor() {
  method decode (line 5644) | static decode(reader, length) {
  method decodeText (line 5661) | static decodeText(reader) {
  method decode (line 5681) | static decode(reader, length) {
  method decodeText (line 5701) | static decodeText(reader) {
  method constructor (line 5737) | constructor() {
  method decode (line 5742) | static decode(reader, length) {
  method decodeText (line 5771) | static decodeText(reader) {
  method decode (line 5807) | static decode(reader, length) {
  method decodeText (line 5836) | static decodeText(reader) {
  method constructor (line 5874) | constructor() {
  method decode (line 5878) | static decode(reader, length) {
  method decodeText (line 5895) | static decodeText(reader) {
  method preprocessor (line 5915) | get preprocessor() {
  method decode (line 5920) | static decode(reader, length) {
  method decodeText (line 5943) | static decodeText(reader) {
  method decode (line 5971) | static decode(reader, length) {
  method decodeText (line 5985) | static decodeText(reader) {
  method decode (line 6002) | static decode(reader, length) {
  method decodeText (line 6019) | static decodeText(reader) {
  method decode (line 6041) | static decode(reader, length) {
  method decodeText (line 6055) | static decodeText(reader) {
  method decode (line 6072) | static decode(reader, length) {
  method decodeText (line 6092) | static decodeText(reader) {
  method decode (line 6118) | static decode(reader, length) {
  method decodeText (line 6132) | static decodeText(reader) {
  method decode (line 6149) | static decode(reader, length) {
  method decodeText (line 6169) | static decodeText(reader) {
  method decode (line 6195) | static decode(reader, length) {
  method decodeText (line 6215) | static decodeText(reader) {
  method decode (line 6241) | static decode(reader, length) {
  method decodeText (line 6258) | static decodeText(reader) {
  method decode (line 6280) | static decode(reader, length) {
  method decodeText (line 6297) | static decodeText(reader) {
  method decode (line 6319) | static decode(reader, length) {
  method decodeText (line 6336) | static decodeText(reader) {
  method decode (line 6358) | static decode(reader, length) {
  method decodeText (line 6372) | static decodeText(reader) {
  method decode (line 6389) | static decode(reader, length) {
  method decodeText (line 6403) | static decodeText(reader) {
  method decode (line 6420) | static decode(reader, length) {
  method decodeText (line 6440) | static decodeText(reader) {
  method NonlinearityType (line 6466) | get NonlinearityType() {
  method decode (line 6471) | static decode(reader, length) {
  method decodeText (line 6524) | static decodeText(reader) {
  method constructor (line 6580) | constructor() {
  method decode (line 6584) | static decode(reader, length) {
  method decodeText (line 6604) | static decodeText(reader) {
  method constructor (line 6629) | constructor() {
  method layer (line 6636) | get layer() {
  method decode (line 6641) | static decode(reader, length) {
  method decodeText (line 7147) | static decodeText(reader) {
  method decode (line 7659) | static decode(reader, length) {
  method decodeText (line 7679) | static decodeText(reader) {
  method decode (line 7705) | static decode(reader, length) {
  method decodeText (line 7731) | static decodeText(reader) {
  method decode (line 7765) | static decode(reader, length) {
  method decodeText (line 7779) | static decodeText(reader) {
  method decode (line 7796) | static decode(reader, length) {
  method decodeText (line 7810) | static decodeText(reader) {
  method decode (line 7827) | static decode(reader, length) {
  method decodeText (line 7841) | static decodeText(reader) {
  method decode (line 7858) | static decode(reader, length) {
  method decodeText (line 7875) | static decodeText(reader) {
  method decode (line 7897) | static decode(reader, length) {
  method decodeText (line 7914) | static decodeText(reader) {
  method decode (line 7936) | static decode(reader, length) {
  method decodeText (line 7953) | static decodeText(reader) {
  method decode (line 7975) | static decode(reader, length) {
  method decodeText (line 7992) | static decodeText(reader) {
  method decode (line 8014) | static decode(reader, length) {
  method decodeText (line 8031) | static decodeText(reader) {
  method decode (line 8053) | static decode(reader, length) {
  method decodeText (line 8070) | static decodeText(reader) {
  method decode (line 8092) | static decode(reader, length) {
  method decodeText (line 8106) | static decodeText(reader) {
  method decode (line 8123) | static decode(reader, length) {
  method decodeText (line 8137) | static decodeText(reader) {
  method decode (line 8154) | static decode(reader, length) {
  method decodeText (line 8168) | static decodeText(reader) {
  method decode (line 8185) | static decode(reader, length) {
  method decodeText (line 8199) | static decodeText(reader) {
  method constructor (line 8216) | constructor() {
  method decode (line 8220) | static decode(reader, length) {
  method decodeText (line 8237) | static decodeText(reader) {
  method decode (line 8257) | static decode(reader, length) {
  method decodeText (line 8277) | static decodeText(reader) {
  method decode (line 8303) | static decode(reader, length) {
  method decodeText (line 8320) | static decodeText(reader) {
  method decode (line 8342) | static decode(reader, length) {
  method decodeText (line 8359) | static decodeText(reader) {
  method decode (line 8386) | static decode(reader, length) {
  method decodeText (line 8403) | static decodeText(reader) {
  method decode (line 8432) | static decode(reader, length) {
  method decodeText (line 8449) | static decodeText(reader) {
  method constructor (line 8478) | constructor() {
  method decode (line 8482) | static decode(reader, length) {
  method decodeText (line 8514) | static decodeText(reader) {
  method QuantizationType (line 8555) | get QuantizationType() {
  method decode (line 8560) | static decode(reader, length) {
  method decodeText (line 8583) | static decodeText(reader) {
  method constructor (line 8611) | constructor() {
  method decode (line 8616) | static decode(reader, length) {
  method decodeText (line 8636) | static decodeText(reader) {
  method constructor (line 8659) | constructor() {
  method decode (line 8663) | static decode(reader, length) {
  method decodeText (line 8680) | static decodeText(reader) {
  method constructor (line 8700) | constructor() {
  method ConvolutionPaddingType (line 8707) | get ConvolutionPaddingType() {
  method decode (line 8712) | static decode(reader, length) {
  method decodeText (line 8765) | static decodeText(reader) {
  method constructor (line 8829) | constructor() {
  method decode (line 8833) | static decode(reader, length) {
  method decodeText (line 8919) | static decodeText(reader) {
  method decode (line 9038) | static decode(reader, length) {
  method decodeText (line 9070) | static decodeText(reader) {
  method decode (line 9112) | static decode(reader, length) {
  method decodeText (line 9141) | static decodeText(reader) {
  method decode (line 9179) | static decode(reader, length) {
  method decodeText (line 9208) | static decodeText(reader) {
  method decode (line 9246) | static decode(reader, length) {
  method decodeText (line 9284) | static decodeText(reader) {
  method constructor (line 9334) | constructor() {
  method PoolingPaddingType (line 9339) | get PoolingPaddingType() {
  method decode (line 9344) | static decode(reader, length) {
  method decodeText (line 9382) | static decodeText(reader) {
  method constructor (line 9433) | constructor() {
  method decode (line 9437) | static decode(reader, length) {
  method decodeText (line 9454) | static decodeText(reader) {
  method decode (line 9474) | static decode(reader, length) {
  method decodeText (line 9533) | static decodeText(reader) {
  method decode (line 9622) | static decode(reader, length) {
  method decodeText (line 9639) | static decodeText(reader) {
  method PaddingType (line 9666) | get PaddingType() {
  method decode (line 9671) | static decode(reader, length) {
  method decodeText (line 9697) | static decodeText(reader) {
  method decode (line 9728) | static decode(reader, length) {
  method decodeText (line 9745) | static decodeText(reader) {
  method decode (line 9767) | static decode(reader, length) {
  method decodeText (line 9781) | static decodeText(reader) {
  method decode (line 9798) | static decode(reader, length) {
  method decodeText (line 9812) | static decodeText(reader) {
  method decode (line 9829) | static decode(reader, length) {
  method decodeText (line 9846) | static decodeText(reader) {
  method decode (line 9868) | static decode(reader, length) {
  method decodeText (line 9894) | static decodeText(reader) {
  method decode (line 9928) | static decode(reader, length) {
  method decodeText (line 9942) | static decodeText(reader) {
  method decode (line 9959) | static decode(reader, length) {
  method decodeText (line 9976) | static decodeText(reader) {
  method decode (line 9998) | static decode(reader, length) {
  method decodeText (line 10015) | static decodeText(reader) {
  method decode (line 10037) | static decode(reader, length) {
  method decodeText (line 10054) | static decodeText(reader) {
  method decode (line 10076) | static decode(reader, length) {
  method decodeText (line 10105) | static decodeText(reader) {
  method constructor (line 10154) | constructor() {
  method decode (line 10159) | static decode(reader, length) {
  method decodeText (line 10185) | static decodeText(reader) {
  method constructor (line 10228) | constructor() {
  method decode (line 10232) | static decode(reader, length) {
  method decodeText (line 10252) | static decodeText(reader) {
  method constructor (line 10277) | constructor() {
  method decode (line 10281) | static decode(reader, length) {
  method decodeText (line 10310) | static decodeText(reader) {
  method constructor (line 10347) | constructor() {
  method decode (line 10351) | static decode(reader, length) {
  method decodeText (line 10371) | static decodeText(reader) {
  method constructor (line 10396) | constructor() {
  method decode (line 10401) | static decode(reader, length) {
  method decodeText (line 10430) | static decodeText(reader) {
  method constructor (line 10466) | constructor() {
  method decode (line 10470) | static decode(reader, length) {
  method decodeText (line 10490) | static decodeText(reader) {
  method decode (line 10515) | static decode(reader, length) {
  method decodeText (line 10532) | static decodeText(reader) {
  method decode (line 10554) | static decode(reader, length) {
  method decodeText (line 10571) | static decodeText(reader) {
  method constructor (line 10598) | constructor() {
  method decode (line 10602) | static decode(reader, length) {
  method decodeText (line 10622) | static decodeText(reader) {
  method constructor (line 10652) | constructor() {
  method decode (line 10656) | static decode(reader, length) {
  method decodeText (line 10673) | static decodeText(reader) {
  method decode (line 10693) | static decode(reader, length) {
  method decodeText (line 10713) | static decodeText(reader) {
  method decode (line 10745) | static decode(reader, length) {
  method decodeText (line 10771) | static decodeText(reader) {
  method decode (line 10811) | static decode(reader, length) {
  method decodeText (line 10834) | static decodeText(reader) {
  method constructor (line 10885) | constructor() {
  method decode (line 10889) | static decode(reader, length) {
  method decodeText (line 10909) | static decodeText(reader) {
  method decode (line 10934) | static decode(reader, length) {
  method decodeText (line 10948) | static decodeText(reader) {
  method decode (line 10965) | static decode(reader, length) {
  method decodeText (line 10979) | static decodeText(reader) {
  method decode (line 10996) | static decode(reader, length) {
  method decodeText (line 11010) | static decodeText(reader) {
  method decode (line 11027) | static decode(reader, length) {
  method decodeText (line 11044) | static decodeText(reader) {
  method decode (line 11066) | static decode(reader, length) {
  method decodeText (line 11089) | static decodeText(reader) {
  method decode (line 11119) | static decode(reader, length) {
  method decodeText (line 11136) | static decodeText(reader) {
  method decode (line 11158) | static decode(reader, length) {
  method decodeText (line 11199) | static decodeText(reader) {
  method constructor (line 11253) | constructor() {
  method decode (line 11257) | static decode(reader, length) {
  method decodeText (line 11316) | static decodeText(reader) {
  method decode (line 11393) | static decode(reader, length) {
  method decodeText (line 11425) | static decodeText(reader) {
  method decode (line 11467) | static decode(reader, length) {
  method decodeText (line 11526) | static decodeText(reader) {
  method constructor (line 11604) | constructor() {
  method decode (line 11608) | static decode(reader, length) {
  method decodeText (line 11640) | static decodeText(reader) {
  method constructor (line 11681) | constructor() {
  method decode (line 11687) | static decode(reader, length) {
  method decodeText (line 11719) | static decodeText(reader) {
  method constructor (line 11758) | constructor() {
  method decode (line 11763) | static decode(reader, length) {
  method decodeText (line 11789) | static decodeText(reader) {
  method value (line 11821) | get value() {
  method decode (line 11826) | static decode(reader, length) {
  method decodeText (line 11855) | static decodeText(reader) {
  method constructor (line 11887) | constructor() {
  method decode (line 11891) | static decode(reader, length) {
  method decodeText (line 11908) | static decodeText(reader) {
  method decode (line 11928) | static decode(reader, length) {
  method decodeText (line 11966) | static decodeText(reader) {
  method decode (line 12016) | static decode(reader, length) {
  method decodeText (line 12036) | static decodeText(reader) {
  method decode (line 12062) | static decode(reader, length) {
  method decodeText (line 12079) | static decodeText(reader) {
  method constructor (line 12101) | constructor() {
  method decode (line 12105) | static decode(reader, length) {
  method decodeText (line 12122) | static decodeText(reader) {
  method decode (line 12142) | static decode(reader, length) {
  method decodeText (line 12162) | static decodeText(reader) {
  method constructor (line 12188) | constructor() {
  method decode (line 12192) | static decode(reader, length) {
  method decodeText (line 12212) | static decodeText(reader) {
  method decode (line 12237) | static decode(reader, length) {
  method decodeText (line 12254) | static decodeText(reader) {
  method constructor (line 12276) | constructor() {
  method decode (line 12280) | static decode(reader, length) {
  method decodeText (line 12300) | static decodeText(reader) {
  method decode (line 12325) | static decode(reader, length) {
  method decodeText (line 12342) | static decodeText(reader) {
  method decode (line 12364) | static decode(reader, length) {
  method decodeText (line 12378) | static decodeText(reader) {
  method decode (line 12395) | static decode(reader, length) {
  method decodeText (line 12409) | static decodeText(reader) {
  method decode (line 12426) | static decode(reader, length) {
  method decodeText (line 12440) | static decodeText(reader) {
  method decode (line 12457) | static decode(reader, length) {
  method decodeText (line 12471) | static decodeText(reader) {
  method decode (line 12488) | static decode(reader, length) {
  method decodeText (line 12502) | static decodeText(reader) {
  method decode (line 12519) | static decode(reader, length) {
  method decodeText (line 12533) | static decodeText(reader) {
  method decode (line 12550) | static decode(reader, length) {
  method decodeText (line 12564) | static decodeText(reader) {
  method decode (line 12581) | static decode(reader, length) {
  method decodeText (line 12595) | static decodeText(reader) {
  method decode (line 12612) | static decode(reader, length) {
  method decodeText (line 12626) | static decodeText(reader) {
  method decode (line 12643) | static decode(reader, length) {
  method decodeText (line 12657) | static decodeText(reader) {
  method decode (line 12674) | static decode(reader, length) {
  method decodeText (line 12688) | static decodeText(reader) {
  method decode (line 12705) | static decode(reader, length) {
  method decodeText (line 12719) | static decodeText(reader) {
  method decode (line 12736) | static decode(reader, length) {
  method decodeText (line 12750) | static decodeText(reader) {
  method decode (line 12767) | static decode(reader, length) {
  method decodeText (line 12781) | static decodeText(reader) {
  method decode (line 12798) | static decode(reader, length) {
  method decodeText (line 12812) | static decodeText(reader) {
  method decode (line 12829) | static decode(reader, length) {
  method decodeText (line 12843) | static decodeText(reader) {
  method decode (line 12860) | static decode(reader, length) {
  method decodeText (line 12880) | static decodeText(reader) {
  method decode (line 12906) | static decode(reader, length) {
  method decodeText (line 12923) | static decodeText(reader) {
  method decode (line 12945) | static decode(reader, length) {
  method decodeText (line 12962) | static decodeText(reader) {
  method decode (line 12984) | static decode(reader, length) {
  method decodeText (line 12998) | static decodeText(reader) {
  method constructor (line 13015) | constructor() {
  method decode (line 13019) | static decode(reader, length) {
  method decodeText (line 13036) | static decodeText(reader) {
  method decode (line 13056) | static decode(reader, length) {
  method decodeText (line 13070) | static decodeText(reader) {
  method decode (line 13087) | static decode(reader, length) {
  method decodeText (line 13101) | static decodeText(reader) {
  method decode (line 13118) | static decode(reader, length) {
  method decodeText (line 13132) | static decodeText(reader) {
  method decode (line 13149) | static decode(reader, length) {
  method decodeText (line 13163) | static decodeText(reader) {
  method decode (line 13180) | static decode(reader, length) {
  method decodeText (line 13194) | static decodeText(reader) {
  method decode (line 13211) | static decode(reader, length) {
  method decodeText (line 13225) | static decodeText(reader) {
  method decode (line 13242) | static decode(reader, length) {
  method decodeText (line 13256) | static decodeText(reader) {
  method decode (line 13273) | static decode(reader, length) {
  method decodeText (line 13287) | static decodeText(reader) {
  method decode (line 13304) | static decode(reader, length) {
  method decodeText (line 13318) | static decodeText(reader) {
  method decode (line 13335) | static decode(reader, length) {
  method decodeText (line 13352) | static decodeText(reader) {
  method decode (line 13384) | static decode(reader, length) {
  method decodeText (line 13404) | static decodeText(reader) {
  method decode (line 13430) | static decode(reader, length) {
  method decodeText (line 13444) | static decodeText(reader) {
  method decode (line 13461) | static decode(reader, length) {
  method decodeText (line 13478) | static decodeText(reader) {
  method decode (line 13500) | static decode(reader, length) {
  method decodeText (line 13517) | static decodeText(reader) {
  method decode (line 13539) | static decode(reader, length) {
  method decodeText (line 13559) | static decodeText(reader) {
  method decode (line 13585) | static decode(reader, length) {
  method decodeText (line 13602) | static decodeText(reader) {
  method constructor (line 13624) | constructor() {
  method decode (line 13628) | static decode(reader, length) {
  method decodeText (line 13645) | static decodeText(reader) {
  method constructor (line 13665) | constructor() {
  method decode (line 13669) | static decode(reader, length) {
  method decodeText (line 13692) | static decodeText(reader) {
  method decode (line 13721) | static decode(reader, length) {
  method decodeText (line 13744) | static decodeText(reader) {
  method constructor (line 13774) | constructor() {
  method decode (line 13778) | static decode(reader, length) {
  method decodeText (line 13804) | static decodeText(reader) {
  method decode (line 13837) | static decode(reader, length) {
  method decodeText (line 13860) | static decodeText(reader) {
  method decode (line 13890) | static decode(reader, length) {
  method decodeText (line 13913) | static decodeText(reader) {
  method constructor (line 13943) | constructor() {
  method decode (line 13947) | static decode(reader, length) {
  method decodeText (line 13973) | static decodeText(reader) {
  method decode (line 14006) | static decode(reader, length) {
  method decodeText (line 14029) | static decodeText(reader) {
  method decode (line 14059) | static decode(reader, length) {
  method decodeText (line 14079) | static decodeText(reader) {
  method constructor (line 14105) | constructor() {
  method decode (line 14109) | static decode(reader, length) {
  method decodeText (line 14132) | static decodeText(reader) {
  method decode (line 14161) | static decode(reader, length) {
  method decodeText (line 14181) | static decodeText(reader) {
  method decode (line 14207) | static decode(reader, length) {
  method decodeText (line 14236) | static decodeText(reader) {
  method constructor (line 14274) | constructor() {
  method decode (line 14278) | static decode(reader, length) {
  method decodeText (line 14301) | static decodeText(reader) {
  method constructor (line 14330) | constructor() {
  method decode (line 14334) | static decode(reader, length) {
  method decodeText (line 14357) | static decodeText(reader) {
  method constructor (line 14386) | constructor() {
  method decode (line 14390) | static decode(reader, length) {
  method decodeText (line 14413) | static decodeText(reader) {
  method constructor (line 14442) | constructor() {
  method decode (line 14446) | static decode(reader, length) {
  method decodeText (line 14469) | static decodeText(reader) {
  method constructor (line 14498) | constructor() {
  method decode (line 14502) | static decode(reader, length) {
  method decodeText (line 14525) | static decodeText(reader) {
  method constructor (line 14554) | constructor() {
  method decode (line 14558) | static decode(reader, length) {
  method decodeText (line 14581) | static decodeText(reader) {
  method constructor (line 14610) | constructor() {
  method decode (line 14614) | static decode(reader, length) {
  method decodeText (line 14637) | static decodeText(reader) {
  method constructor (line 14666) | constructor() {
  method decode (line 14670) | static decode(reader, length) {
  method decodeText (line 14693) | static decodeText(reader) {
  method constructor (line 14722) | constructor() {
  method decode (line 14726) | static decode(reader, length) {
  method decodeText (line 14749) | static decodeText(reader) {
  method constructor (line 14778) | constructor() {
  method decode (line 14782) | static decode(reader, length) {
  method decodeText (line 14805) | static decodeText(reader) {
  method constructor (line 14834) | constructor() {
  method decode (line 14838) | static decode(reader, length) {
  method decodeText (line 14855) | static decodeText(reader) {
  method decode (line 14875) | static decode(reader, length) {
  method decodeText (line 14892) | static decodeText(reader) {
  method constructor (line 14914) | constructor() {
  method decode (line 14918) | static decode(reader, length) {
  method decodeText (line 14935) | static decodeText(reader) {
  method decode (line 14955) | static decode(reader, length) {
  method decodeText (line 14969) | static decodeText(reader) {
  method decode (line 14986) | static decode(reader, length) {
  method decodeText (line 15000) | static decodeText(reader) {
  method constructor (line 15017) | constructor() {
  method decode (line 15021) | static decode(reader, length) {
  method decodeText (line 15041) | static decodeText(reader) {
  method decode (line 15066) | static decode(reader, length) {
  method decodeText (line 15089) | static decodeText(reader) {
  method decode (line 15119) | static decode(reader, length) {
  method decodeText (line 15139) | static decodeText(reader) {
  method decode (line 15165) | static decode(reader, length) {
  method decodeText (line 15185) | static decodeText(reader) {
  method constructor (line 15211) | constructor() {
  method decode (line 15215) | static decode(reader, length) {
  method decodeText (line 15238) | static decodeText(reader) {
  method decode (line 15267) | static decode(reader, length) {
  method decodeText (line 15281) | static decodeText(reader) {
  method decode (line 15298) | static decode(reader, length) {
  method decodeText (line 15312) | static decodeText(reader) {
  method decode (line 15329) | static decode(reader, length) {
  method decodeText (line 15343) | static decodeText(reader) {
  method decode (line 15360) | static decode(reader, length) {
  method decodeText (line 15374) | static decodeText(reader) {
  method decode (line 15391) | static decode(reader, length) {
  method decodeText (line 15411) | static decodeText(reader) {
  method constructor (line 15437) | constructor() {
  method decode (line 15446) | static decode(reader, length) {
  method decodeText (line 15478) | static decodeText(reader) {
  method constructor (line 15513) | constructor() {
  method decode (line 15521) | static decode(reader, length) {
  method decodeText (line 15550) | static decodeText(reader) {
  method constructor (line 15582) | constructor() {
  method decode (line 15586) | static decode(reader, length) {
  method decodeText (line 15603) | static decodeText(reader) {
  method decode (line 15623) | static decode(reader, length) {
  method decodeText (line 15637) | static decodeText(reader) {
  method decode (line 15654) | static decode(reader, length) {
  method decodeText (line 15668) | static decodeText(reader) {
  method decode (line 15685) | static decode(reader, length) {
  method decodeText (line 15702) | static decodeText(reader) {
  method decode (line 15730) | static decode(reader, length) {
  method decodeText (line 15753) | static decodeText(reader) {
  method decode (line 15783) | static decode(reader, length) {
  method decodeText (line 15803) | static decodeText(reader) {
  method decode (line 15829) | static decode(reader, length) {
  method decodeText (line 15852) | static decodeText(reader) {
  method constructor (line 15882) | constructor() {
  method decode (line 15886) | static decode(reader, length) {
  method decodeText (line 15912) | static decodeText(reader) {
  method decode (line 15945) | static decode(reader, length) {
  method decodeText (line 15971) | static decodeText(reader) {
  method decode (line 16005) | static decode(reader, length) {
  method decodeText (line 16025) | static decodeText(reader) {
  method decode (line 16051) | static decode(reader, length) {
  method decodeText (line 16071) | static decodeText(reader) {
  method decode (line 16097) | static decode(reader, length) {
  method decodeText (line 16117) | static decodeText(reader) {
  method constructor (line 16143) | constructor() {
  method ClassLabels (line 16148) | get ClassLabels() {
  method decode (line 16153) | static decode(reader, length) {
  method decodeText (line 16191) | static decodeText(reader) {
  method decode (line 16237) | static decode(reader, length) {
  method decodeText (line 16263) | static decodeText(reader) {
  method decode (line 16297) | static decode(reader, length) {
  method decodeText (line 16320) | static decodeText(reader) {
  method constructor (line 16350) | constructor() {
  method decode (line 16355) | static decode(reader, length) {
  method decodeText (line 16384) | static decodeText(reader) {
  method constructor (line 16420) | constructor() {
  method decode (line 16424) | static decode(reader, length) {
  method decodeText (line 16453) | static decodeText(reader) {
  method LossLayerType (line 16490) | get LossLayerType() {
  method decode (line 16495) | static decode(reader, length) {
  method decodeText (line 16518) | static decodeText(reader) {
  method decode (line 16546) | static decode(reader, length) {
  method decodeText (line 16566) | static decodeText(reader) {
  method decode (line 16592) | static decode(reader, length) {
  method decodeText (line 16612) | static decodeText(reader) {
  method OptimizerType (line 16638) | get OptimizerType() {
  method decode (line 16643) | static decode(reader, length) {
  method decodeText (line 16663) | static decodeText(reader) {
  method decode (line 16686) | static decode(reader, length) {
  method decodeText (line 16709) | static decodeText(reader) {
  method decode (line 16739) | static decode(reader, length) {
  method decodeText (line 16768) | static decodeText(reader) {
  method decode (line 16806) | static decode(reader, length) {
  method decodeText (line 16823) | static decodeText(reader) {
  method CategoryType (line 16851) | get CategoryType() {
  method decode (line 16856) | static decode(reader, length) {
  method decodeText (line 16882) | static decodeText(reader) {
  method constructor (line 16919) | constructor() {
  method decode (line 16924) | static decode(reader, length) {
  method decodeText (line 16944) | static decodeText(reader) {
  method SuppressionMethod (line 16967) | get SuppressionMethod() {
  method ClassLabels (line 16972) | get ClassLabels() {
  method decode (line 16977) | static decode(reader, length) {
  method decodeText (line 17024) | static decodeText(reader) {
  method decode (line 17083) | static decode(reader, length) {
  method decodeText (line 17100) | static decodeText(reader) {
  method decode (line 17122) | static decode(reader, length) {
  method decodeText (line 17136) | static decodeText(reader) {
  method decode (line 17153) | static decode(reader, length) {
  method decodeText (line 17170) | static decodeText(reader) {
  method decode (line 17192) | static decode(reader, length) {
  method decodeText (line 17215) | static decodeText(reader) {
  method decode (line 17245) | static decode(reader, length) {
  method decodeText (line 17265) | static decodeText(reader) {
  method kernel (line 17291) | get kernel() {
  method decode (line 17296) | static decode(reader, length) {
  method decodeText (line 17322) | static decodeText(reader) {
  method decode (line 17351) | static decode(reader, length) {
  method decodeText (line 17371) | static decodeText(reader) {
  method constructor (line 17397) | constructor() {
  method decode (line 17401) | static decode(reader, length) {
  method decodeText (line 17418) | static decodeText(reader) {
  method constructor (line 17438) | constructor() {
  method decode (line 17442) | static decode(reader, length) {
  method decodeText (line 17459) | static decodeText(reader) {
  method constructor (line 17479) | constructor() {
  method decode (line 17483) | static decode(reader, length) {
  method decodeText (line 17500) | static decodeText(reader) {
  method constructor (line 17520) | constructor() {
  method decode (line 17524) | static decode(reader, length) {
  method decodeText (line 17541) | static decodeText(reader) {
  method constructor (line 17561) | constructor() {
  method decode (line 17565) | static decode(reader, length) {
  method decodeText (line 17582) | static decodeText(reader) {
  method supportVectors (line 17602) | get supportVectors() {
  method decode (line 17607) | static decode(reader, length) {
  method decodeText (line 17636) | static decodeText(reader) {
  method constructor (line 17672) | constructor() {
  method supportVectors (line 17680) | get supportVectors() {
  method ClassLabels (line 17685) | get ClassLabels() {
  method decode (line 17690) | static decode(reader, length) {
  method decodeText (line 17734) | static decodeText(reader) {
  method constructor (line 17790) | constructor() {
  method decode (line 17795) | static decode(reader, length) {
  method decodeText (line 17818) | static decodeText(reader) {
  method constructor (line 17846) | constructor() {
  method decode (line 17850) | static decode(reader, length) {
  method decodeText (line 17894) | static decodeText(reader) {
  method decode (line 17961) | static decode(reader, length) {
  method decodeText (line 17981) | static decodeText(reader) {
  method ClassLabels (line 18007) | get ClassLabels() {
  method decode (line 18012) | static decode(reader, length) {
  method decodeText (line 18038) | static decodeText(reader) {
  method decode (line 18070) | static decode(reader, length) {
  method decodeText (line 18090) | static decodeText(reader) {
  method constructor (line 18116) | constructor() {
  method decode (line 18120) | static decode(reader, length) {
  method decodeText (line 18161) | static decodeText(reader) {
  method decode (line 18214) | static decode(reader, length) {
  method decodeText (line 18234) | static decodeText(reader) {
  method constructor (line 18260) | constructor() {
  method decode (line 18264) | static decode(reader, length) {
  method decodeText (line 18287) | static decodeText(reader) {
  method LinkType (line 18316) | get LinkType() {
  method decode (line 18321) | static decode(reader, length) {
  method decodeText (line 18338) | static decodeText(reader) {
  method decode (line 18358) | static decode(reader, length) {
  method decodeText (line 18378) | static decodeText(reader) {
  method constructor (line 18404) | constructor() {
  method decode (line 18408) | static decode(reader, length) {
  method decodeText (line 18425) | static decodeText(reader) {

FILE: source/coreml.js
  method match (line 8) | async match(context) {
  method filter (line 77) | filter(context, match) {
  method open (line 84) | async open(context) {
  method constructor (line 212) | constructor(context) {
  method constructor (line 228) | constructor(context) {
  method constructor (line 271) | constructor(name, value, type = null, visible = true) {
  method constructor (line 281) | constructor(name, type, description = null, initializer = null) {
  method constructor (line 295) | constructor(context, obj) {
  method constructor (line 354) | constructor(type, values, quantization, category) {
  method constructor (line 390) | constructor(dataType, shape) {
  method equals (line 395) | equals(obj) {
  method toString (line 399) | toString() {
  method constructor (line 406) | constructor(dimensions) {
  method equals (line 410) | equals(obj) {
  method toString (line 416) | toString() {
  method constructor (line 424) | constructor(elementType) {
  method equals (line 428) | equals(obj) {
  method toString (line 432) | toString() {
  method constructor (line 439) | constructor(keyType, valueType) {
  method equals (line 444) | equals(obj) {
  method toString (line 448) | toString() {
  method constructor (line 455) | constructor(type) {
  method equals (line 459) | equals(obj) {
  method toString (line 463) | toString() {
  method constructor (line 470) | constructor(colorSpace, width, height) {
  method equals (line 491) | equals(obj) {
  method toString (line 495) | toString() {
  method constructor (line 502) | constructor(type) {
  method equals (line 506) | equals(obj) {
  method toString (line 510) | toString() {
  method constructor (line 517) | constructor(type) {
  method equals (line 521) | equals(obj) {
  method toString (line 525) | toString() {
  method constructor (line 532) | constructor(metadata, format, model, weights, values) {
  method constructor (line 576) | constructor(metadata, name, type, model, description, weights, values) {
  method context (line 608) | context() {
  method network (line 612) | network(obj) {
  method input (line 623) | input(name) {
  method output (line 630) | output(name) {
  method update (line 646) | update(value, description) {
  method node (line 655) | node(group, type, name, description, data, inputs, outputs, inputTensors...
  method model (line 878) | model(model, group, description) {
  method updateClassifierOutput (line 1158) | updateClassifierOutput(group, classifier, description) {
  method updatePreprocessing (line 1204) | updatePreprocessing(group, preprocessings, description) {
  method program (line 1238) | program(program, group) {
  method enum (line 1437) | static enum(name, value) {
  method featureType (line 1457) | static featureType(type) {
  method tensorType (line 1534) | static tensorType(type) {
  method valueType (line 1548) | static valueType(type) {
  method constructor (line 1563) | constructor(message) {

FILE: source/dagre.js
  method constructor (line 2232) | constructor(directed, compound) {
  method setDefaultNodeLabel (line 2247) | setDefaultNodeLabel(newDefault) {
  method setNode (line 2251) | setNode(v, label) {
  method node (line 2268) | node(v) {
  method hasNode (line 2272) | hasNode(v) {
  method removeNode (line 2276) | removeNode(v) {
  method setParent (line 2297) | setParent(v, parent) {
  method parent (line 2316) | parent(v) {
  method children (line 2326) | children(v) {
  method hasChildren (line 2337) | hasChildren(v) {
  method predecessors (line 2346) | predecessors(v) {
  method successors (line 2350) | successors(v) {
  method neighbors (line 2354) | neighbors(v) {
  method edge (line 2368) | edge(v, w) {
  method setEdge (line 2372) | setEdge(v, w, label, name) {
  method removeEdge (line 2399) | removeEdge(edge) {
  method _edgeKey (line 2433) | _edgeKey(isDirected, v, w, name) {
  method toString (line 2440) | toString() {

FILE: source/darknet.js
  method match (line 6) | async match(context) {
  method open (line 35) | async open(context) {
  method constructor (line 73) | constructor(metadata, configuration, weights) {
  method constructor (line 81) | constructor(metadata, configuration, weights) {
  method constructor (line 782) | constructor(name, value, type = null, visible = true) {
  method constructor (line 793) | constructor(name, type, initializer) {
  method constructor (line 805) | constructor(metadata, net, section) {
  method constructor (line 879) | constructor(type, data) {
  method constructor (line 887) | constructor(dataType, shape) {
  method toString (line 892) | toString() {
  method constructor (line 899) | constructor(dimensions) {
  method toString (line 906) | toString() {
  method constructor (line 919) | constructor(reader, identifier) {
  method read (line 924) | read() {
  method open (line 978) | static async open(context) {
  method constructor (line 994) | constructor(reader, offset) {
  method read (line 999) | read(size) {
  method validate (line 1005) | validate() {
  method constructor (line 1014) | constructor(message) {

FILE: source/desktop.mjs
  method constructor (line 18) | constructor() {
  method window (line 75) | get window() {
  method document (line 79) | get document() {
  method version (line 83) | get version() {
  method type (line 87) | get type() {
  method metadata (line 91) | get metadata() {
  method view (line 95) | async view(view) {
  method start (line 157) | async start() {
  method environment (line 272) | environment(name) {
  method error (line 276) | async error(message) {
  method require (line 280) | async require(id) {
  method worker (line 284) | worker(id) {
  method save (line 288) | async save(name, extension, defaultPath) {
  method export (line 308) | async export(file, blob) {
  method execute (line 332) | async execute(name, value) {
  method request (line 345) | async request(file, encoding, basename) {
  method openURL (line 374) | openURL(url) {
  method exception (line 378) | exception(error, fatal) {
  method event (line 423) | event(name, params) {
  method _context (line 432) | async _context(location) {
  method _open (line 460) | async _open(location) {
  method _request (line 507) | _request(location, headers, timeout) {
  method get (line 548) | get(name) {
  method set (line 557) | set(name, value) {
  method delete (line 565) | delete(name) {
  method _title (line 573) | _title(label) {
  method _element (line 588) | _element(id) {
  method update (line 592) | update(data) {
  method message (line 596) | async message(message, alert, action) {
  method constructor (line 628) | constructor(host, folder, identifier, stream, entries) {
  method identifier (line 636) | get identifier() {
  method stream (line 640) | get stream() {
  method entries (line 644) | get entries() {
  method request (line 648) | async request(file, encoding, base) {
  method require (line 652) | async require(id) {
  method error (line 656) | error(error, fatal) {

FILE: source/dl4j.js
  method match (line 8) | async match(context) {
  method filter (line 25) | filter(context, match) {
  method open (line 29) | async open(context) {
  method constructor (line 57) | constructor(metadata, configuration, coefficients) {
  method constructor (line 65) | constructor(metadata, configuration, coefficients) {
  method constructor (line 146) | constructor(name, value, visible = true) {
  method constructor (line 155) | constructor(name, type, initializer) {
  method constructor (line 167) | constructor(metadata, layer, inputs, dataType, variables, values) {
  method _object (line 275) | static _object(value) {
  method constructor (line 299) | constructor(dataType, shape) {
  method constructor (line 306) | constructor(dataType, shape) {
  method toString (line 311) | toString() {
  method constructor (line 318) | constructor(dimensions) {
  method toString (line 322) | toString() {
  method constructor (line 335) | constructor(reader) {
  method constructor (line 389) | constructor(reader) {
  method length (line 393) | get length() {
  method position (line 397) | get position() {
  method read (line 401) | read(length) {
  method int32 (line 405) | int32() {
  method int64 (line 409) | int64() {
  method uint16 (line 413) | uint16() {
  method string (line 417) | string() {
  method constructor (line 427) | constructor(message) {

FILE: source/dlc-schema.js
  method decode (line 8) | static decode(reader, position) {
  method decode (line 21) | static decode(reader, position) {
  method decode (line 35) | static decode(reader, position) {
  method decode (line 47) | static decode(reader, position) {
  method decode (line 58) | static decode(reader, position) {
  method decode (line 84) | static decode(reader, position) {
  method decode (line 93) | static decode(reader, position) {
  method decode (line 105) | static decode(reader, position) {
  method decode (line 114) | static decode(reader, position) {
  method decode (line 125) | static decode(reader, position) {
  method decode (line 138) | static decode(reader, position) {
  method decode (line 151) | static decode(reader, position) {
  method decode (line 163) | static decode(reader, position) {
  method decode (line 180) | static decode(reader, position) {
  method decode (line 192) | static decode(reader, position) {
  method decode (line 205) | static decode(reader, position) {
  method decode (line 215) | static decode(reader, position) {
  method decode (line 229) | static decode(reader, position) {
  method decode (line 239) | static decode(reader, position) {
  method decode (line 248) | static decode(reader, position) {
  method decode (line 259) | static decode(reader, position) {
  method decode (line 268) | static decode(reader, position) {
  method decode (line 278) | static decode(reader, position) {

FILE: source/dlc.js
  method match (line 9) | async match(context) {
  method open (line 17) | async open(context) {
  method constructor (line 28) | constructor(metadata, target) {
  method constructor (line 57) | constructor(metadata, version, graph) {
  method constructor (line 128) | constructor(name, value, type = null) {
  method constructor (line 137) | constructor(name, type, initializer) {
  method constructor (line 149) | constructor(metadata, version, obj, value) {
  method constructor (line 221) | constructor(dataType, shape) {
  method toString (line 226) | toString() {
  method constructor (line 233) | constructor(dimensions) {
  method toString (line 237) | toString() {
  method constructor (line 247) | constructor(name, type, data) {
  method open (line 266) | static async open(context) {
  method constructor (line 299) | constructor(context, model, params, metadata) {
  method read (line 306) | async read() {
  method _model3 (line 378) | static _model3(stream, offset) {
  method _model4 (line 426) | static _model4(stream) {
  method _params3 (line 525) | static _params3(stream, signature, graph) {
  method _params4 (line 571) | static _params4(stream, graphs, signature) {
  method _fetch (line 632) | async _fetch(name) {
  method _signature (line 641) | static _signature(stream) {
  method constructor (line 672) | constructor(message) {

FILE: source/dnn-proto.js
  method constructor (line 6) | constructor() {
  method decode (line 14) | static decode(reader, length) {
  method decode (line 59) | static decode(reader, length) {
  method decode (line 85) | static decode(reader, length) {
  method constructor (line 119) | constructor() {
  method decode (line 124) | static decode(reader, length) {
  method constructor (line 152) | constructor() {
  method decode (line 156) | static decode(reader, length) {
  method decode (line 293) | static decode(reader, length) {
  method decode (line 315) | static decode(reader, length) {

FILE: source/dnn.js
  method match (line 8) | async match(context) {
  method open (line 16) | async open(context) {
  method constructor (line 34) | constructor(metadata, model) {
  method constructor (line 43) | constructor(metadata, model) {
  method constructor (line 100) | constructor(name, value) {
  method constructor (line 108) | constructor(name, type = null, initializer = null, quantization = null) {
  method constructor (line 126) | constructor(metadata, node, values) {
  method constructor (line 192) | constructor(weight, quantization) {
  method constructor (line 214) | constructor(dataType, shape) {
  method toString (line 219) | toString() {
  method constructor (line 226) | constructor(shape) {
  method toString (line 230) | toString() {
  method constructor (line 240) | constructor(message) {

FILE: source/dot.js
  method match (line 6) | async match(context) {
  method open (line 29) | async open(context) {
  method constructor (line 42) | constructor(graph) {
  method constructor (line 50) | constructor(graph) {
  method constructor (line 208) | constructor(name, value, type = null) {
  method constructor (line 217) | constructor(name, type, initializer, metadata) {
  method constructor (line 227) | constructor(node, values) {
  method constructor (line 260) | constructor(type) {
  method toString (line 272) | toString() {
  method constructor (line 279) | constructor(dimensions) {
  method toString (line 283) | toString() {
  method constructor (line 293) | constructor(stmt) {
  method constructor (line 305) | constructor(decoder) {
  method parse (line 311) | parse() {
  method _parseBlock (line 338) | _parseBlock(defaults, edgeop) {
  method _parseNodeIds (line 397) | _parseNodeIds() {
  method _parseNodeId (line 421) | _parseNodeId() {
  method _parseAttributes (line 438) | _parseAttributes() {
  method _parseEdges (line 455) | _parseEdges(sources, edgeop, defaults) {
  method _match (line 474) | _match(kind, value) {
  method _read (line 478) | _read(kind, value) {
  method _eat (line 490) | _eat(kind, value) {
  method constructor (line 500) | constructor(decoder) {
  method _read (line 506) | _read() {
  method _peek (line 516) | _peek() {
  method read (line 523) | read() {
  method _skipWhitespace (line 553) | _skipWhitespace() {
  method _skipComment (line 559) | _skipComment() {
  method _identifier (line 577) | _identifier() {
  method _unexpected (line 606) | _unexpected() {
  method _throw (line 624) | _throw(message) {
  method location (line 629) | location() {
  method constructor (line 656) | constructor(message) {

FILE: source/espdl-schema.js
  method decode (line 49) | static decode(reader, position) {
  method decode (line 58) | static decode(reader, position) {
  method decode (line 67) | static decode(reader, position) {
  method decode (line 91) | static decode(reader, position) {
  method decode (line 103) | static decode(reader, position) {
  method create (line 118) | static create(reader) {
  method decode (line 122) | static decode(reader, position) {
  method decode (line 140) | static decode(reader, position) {
  method decode (line 150) | static decode(reader, position) {
  method decode (line 160) | static decode(reader, position) {
  method decode (line 178) | static decode(reader, position) {
  method decode (line 187) | static decode(reader, position) {
  method decode (line 209) | static decode(reader, position) {
  method decode (line 218) | static decode(reader, position) {
  method decode (line 234) | static decode(reader, position) {
  method decode (line 245) | static decode(reader, position) {
  method decode (line 255) | static decode(reader, position) {
  method decode (line 264) | static decode(reader, position) {
  method decode (line 274) | static decode(reader, position) {
  method decode (line 283) | static decode(reader, position, type) {
  method decode (line 296) | static decode(reader, position) {
  method decode (line 306) | static decode(reader, position) {
  method decode (line 316) | static decode(reader, position) {

FILE: source/espdl.js
  method match (line 7) | async match(context) {
  method open (line 23) | async open(context) {
  method constructor (line 42) | constructor(metadata, model, stream) {
  method constructor (line 61) | constructor(metadata, graph) {
  method constructor (line 101) | constructor(name, value, type, visible) {
  method constructor (line 111) | constructor(name, type, initializer) {
  method constructor (line 120) | constructor(metadata, context, node, identifier) {
  method constructor (line 211) | constructor(index, tensor) {
  method constructor (line 239) | constructor(tensor) {
  method toString (line 271) | toString() {
  method constructor (line 278) | constructor(dimensions) {
  method toString (line 282) | toString() {
  method open (line 292) | static async open(context) {
  method constructor (line 305) | constructor(data) {
  method type (line 322) | type(domain, name) {
  method constructor (line 341) | constructor(graph) {
  method value (line 384) | value(name) {
  method initializer (line 391) | initializer(name) {
  method constructor (line 398) | constructor(message) {

FILE: source/espresso.js
  method match (line 6) | async match(context) {
  method filter (line 27) | filter(context, match) {
  method open (line 37) | async open(context) {
  method constructor (line 64) | constructor(metadata, reader) {
  method constructor (line 82) | constructor(metadata, reader) {
  method constructor (line 123) | constructor(name, value, type = null, visible = true) {
  method constructor (line 133) | constructor(name, type, description = null, initializer = null) {
  method constructor (line 147) | constructor(metadata, obj) {
  method constructor (line 194) | constructor(type, data, quantization, category) {
  method constructor (line 205) | constructor(dataType, shape) {
  method equals (line 210) | equals(obj) {
  method toString (line 214) | toString() {
  method constructor (line 221) | constructor(dimensions) {
  method equals (line 225) | equals(obj) {
  method toString (line 231) | toString() {
  method constructor (line 239) | constructor(net, weights, shape) {
  method read (line 243) | async read(context) {
  method _value (line 397) | _value(name) {
  method _weights (line 406) | _weights(obj, data, dimensions) {
  method _initializer (line 435) | _initializer(name, identifier, dataType, dimensions) {
  method constructor (line 455) | constructor(message) {

FILE: source/executorch-schema.js
  method decode (line 36) | static decode(reader, position) {
  method decode (line 46) | static decode(/* reader, position */) {
  method decode (line 54) | static decode(reader, position) {
  method decode (line 76) | static decode(reader, position) {
  method decode (line 87) | static decode(reader, position) {
  method decode (line 105) | static decode(reader, position) {
  method decode (line 114) | static decode(reader, position) {
  method decode (line 123) | static decode(reader, position) {
  method decode (line 132) | static decode(reader, position) {
  method decode (line 141) | static decode(reader, position) {
  method decode (line 150) | static decode(reader, position) {
  method decode (line 159) | static decode(reader, position) {
  method decode (line 168) | static decode(reader, position) {
  method decode (line 177) | static decode(reader, position) {
  method decode (line 186) | static decode(reader, position, type) {
  method decode (line 206) | static decode(reader, position) {
  method decode (line 215) | static decode(reader, position) {
  method decode (line 225) | static decode(reader, position) {
  method decode (line 235) | static decode(reader, position) {
  method decode (line 245) | static decode(reader, position) {
  method decode (line 255) | static decode(reader, position) {
  method decode (line 265) | static decode(reader, position) {
  method decode (line 274) | static decode(reader, position, type) {
  method decode (line 288) | static decode(reader, position) {
  method decode (line 297) | static decode(reader, position) {
  method decode (line 309) | static decode(reader, position) {
  method decode (line 323) | static decode(reader, position) {
  method decode (line 333) | static decode(reader, position) {
  method decode (line 343) | static decode(reader, position) {
  method decode (line 354) | static decode(reader, position) {
  method decode (line 366) | static decode(reader, position) {
  method decode (line 383) | static decode(reader, position) {
  method decode (line 392) | static decode(reader, position) {
  method decode (line 401) | static decode(reader, position) {
  method decode (line 411) | static decode(reader, position) {
  method decode (line 421) | static decode(reader, position) {
  method identifier (line 431) | static identifier(reader) {
  method create (line 435) | static create(reader) {
  method decode (line 439) | static decode(reader, position) {
  method decode (line 473) | static decode(reader, position, type) {
  method decode (line 486) | static decode(reader, position) {
  method decode (line 495) | static decode(reader, position) {
  method decode (line 509) | static decode(reader, position) {
  method decode (line 521) | static decode(reader, position) {
  method decode (line 530) | static decode(reader, position) {
  method decode (line 540) | static decode(reader, position) {
  method decode (line 555) | static decode(reader, position) {
  method decode (line 565) | static decode(reader, position, type) {
  method decode (line 621) | static decode(reader, position, type) {
  method decode (line 632) | static decode(reader, position) {
  method decode (line 642) | static decode(reader, position) {
  method decode (line 653) | static decode(reader, position) {
  method decode (line 662) | static decode(reader, position) {
  method decode (line 675) | static decode(reader, position) {
  method decode (line 688) | static decode(reader, position) {
  method decode (line 702) | static decode(reader, position, $) {
  method decode (line 714) | static decode(reader, position, $) {
  method decode (line 725) | static decode(reader, position, $) {
  method decode (line 741) | static decode(reader, position) {
  method decode (line 753) | static decode(reader, position) {
  method decode (line 766) | static decode(reader, position, $) {
  method decode (line 794) | static decode(reader, position, $) {
  method decode (line 815) | static decode(reader, position) {
  method decode (line 828) | static decode(reader, position) {
  method decode (line 842) | static decode(reader, position) {
  method decode (line 857) | static decode(reader, position) {
  method decode (line 875) | static decode(reader, position) {
  method decode (line 887) | static decode(reader, position) {
  method identifier (line 898) | static identifier(reader) {
  method create (line 902) | static create(reader) {
  method decode (line 906) | static decode(reader, position) {
  method decode (line 923) | static decode(reader, position) {
  method decode (line 932) | static decode(reader, position) {
  method decode (line 941) | static decode(reader, position) {
  method decode (line 950) | static decode(reader, position) {
  method decode (line 959) | static decode(reader, position) {
  method decode (line 968) | static decode(reader, position) {
  method decode (line 977) | static decode(reader, position) {
  method decode (line 986) | static decode(reader, position) {
  method decode (line 995) | static decode(reader, position) {
  method decode (line 1004) | static decode(reader, position) {
  method decode (line 1013) | static decode(reader, position) {
  method decode (line 1022) | static decode(reader, position) {
  method decode (line 1031) | static decode(reader, position) {
  method decode (line 1040) | static decode(reader, position) {
  method decode (line 1049) | static decode(reader, position) {
  method decode (line 1058) | static decode(reader, position) {
  method decode (line 1067) | static decode(reader, position) {
  method decode (line 1076) | static decode(reader, position) {
  method decode (line 1085) | static decode(reader, position) {
  method decode (line 1094) | static decode(reader, position) {
  method decode (line 1103) | static decode(reader, position) {
  method decode (line 1112) | static decode(reader, position) {
  method decode (line 1121) | static decode(reader, position) {
  method decode (line 1130) | static decode(reader, position) {
  method decode (line 1139) | static decode(reader, position) {
  method decode (line 1148) | static decode(reader, position) {
  method decode (line 1157) | static decode(reader, position) {
  method decode (line 1166) | static decode(reader, position) {
  method decode (line 1175) | static decode(reader, position) {
  method decode (line 1184) | static decode(reader, position) {
  method decode (line 1193) | static decode(reader, position) {
  method decode (line 1202) | static decode(reader, position) {
  method decode (line 1211) | static decode(reader, position) {
  method decode (line 1220) | static decode(reader, position) {
  method decode (line 1229) | static decode(reader, position) {
  method decode (line 1238) | static decode(reader, position) {
  method decode (line 1247) | static decode(reader, position) {
  method decode (line 1256) | static decode(reader, position) {
  method decode (line 1299) | static decode(reader, position) {
  method decode (line 1314) | static decode(/* reader, position */) {
  method decode (line 1322) | static decode(reader, position) {
  method decode (line 1331) | static decode(reader, position) {
  method decode (line 1340) | static decode(reader, position) {
  method decode (line 1349) | static decode(reader, position) {
  method decode (line 1358) | static decode(reader, position) {
  method decode (line 1367) | static decode(reader, position) {
  method decode (line 1376) | static decode(reader, position) {
  method decode (line 1385) | static decode(reader, position) {
  method decode (line 1394) | static decode(reader, position) {
  method decode (line 1403) | static decode(reader, position, type) {
  method decode (line 1423) | static decode(reader, position) {
  method decode (line 1432) | static decode(reader, position) {
  method identifier (line 1443) | static identifier(reader) {
  method create (line 1447) | static create(reader) {
  method decode (line 1451) | static decode(reader, position) {

FILE: source/executorch.js
  method match (line 19) | async match(context) {
  method open (line 27) | async open(context) {
  method constructor (line 37) | constructor(target) {
  method constructor (line 51) | constructor(target, plan, chain) {
  method constructor (line 135) | constructor(name, value, type = null, visible = true) {
  method constructor (line 145) | constructor(name, type, initializer = null) {
  method constructor (line 157) | constructor(target, plan, chain, instruction, values) {
  method constructor (line 240) | constructor(tensor) {
  method toString (line 279) | toString() {
  method constructor (line 286) | constructor(dimensions = []) {
  method toString (line 290) | toString() {
  method constructor (line 300) | constructor(tensor, target) {
  method open (line 333) | static async open(context) {
  method constructor (line 341) | constructor(context, reader) {
  method read (line 346) | async read() {
  method blob (line 430) | blob(offset, size) {
  method segment (line 441) | segment(key) {
  method constructor (line 457) | constructor(message) {
  method open (line 465) | static open(data, target) {
  method constructor (line 477) | constructor(reader, target) {
  method read (line 491) | async read() {
  method constant (line 505) | constant(idx) {
  method constructor (line 522) | constructor(metadata, graph, reader) {
  method constructor (line 571) | constructor(metadata, xnode, values) {
  method constructor (line 596) | constructor(name, value, type = null, visible = true) {
  method constructor (line 606) | constructor(name, type, initializer = null) {
  method constructor (line 618) | constructor() {
  method register (line 647) | register(name, category) {
  method type (line 651) | type(name) {
  method constructor (line 658) | constructor(tensor) {
  method toString (line 673) | toString() {
  method constructor (line 680) | constructor(dimensions = []) {
  method toString (line 684) | toString() {
  method constructor (line 694) | constructor(tensor, reader) {
  method constructor (line 703) | constructor(message) {
  method open (line 711) | static open(data, target) {
  method constructor (line 723) | constructor(reader, target) {
  method read (line 737) | async read() {
  method constant (line 752) | constant(id) {
  method constructor (line 765) | constructor(metadata, graph, reader) {
  method constructor (line 819) | constructor(metadata, op, values) {
  method constructor (line 851) | constructor(name, value, type = null, visible = true) {
  method constructor (line 861) | constructor(name, type, initializer = null) {
  method constructor (line 873) | constructor(tensor) {
  method toString (line 895) | toString() {
  method constructor (line 902) | constructor(dimensions = []) {
  method toString (line 906) | toString() {
  method constructor (line 916) | constructor(tensor, reader) {
  method constructor (line 925) | constructor(execution) {
  method register (line 929) | register(signature) {
  method type (line 937) | type(identifier) {
  method constructor (line 950) | constructor(message) {
  method open (line 958) | static open(data, target) {
  method constructor (line 963) | constructor(reader, target) {
  method factory (line 968) | async factory() {
  method read (line 973) | async read() {
  method stream (line 997) | stream(offset, size) {
  method entries (line 1004) | entries(reader) {
  method constructor (line 1050) | constructor(reader, identifier, location, entries, protobuf) {
  method identifier (line 1058) | get identifier() {
  method stream (line 1062) | get stream() {
  method tags (line 1069) | async tags(type) {
  method peek (line 1076) | async peek(type) {
  method read (line 1086) | async read(type) {
  method fetch (line 1093) | async fetch(file) {
  method require (line 1102) | async require(id) {
  method metadata (line 1106) | async metadata(name) {
  method set (line 1110) | set(type, value) {
  method open (line 1119) | static open(data, target) {
  method constructor (line 1130) | constructor(reader, target) {
  method read (line 1137) | async read() {
  method constructor (line 1145) | constructor() {
  method open (line 1155) | static open(data /* , target */) {
  method constructor (line 1167) | constructor(reader, size) {
  method read (line 1172) | async read() {
  method constructor (line 1215) | constructor(inputs, outputs) {
  method constructor (line 1241) | constructor(name, value, type = null, visible = true) {
  method constructor (line 1251) | constructor(name, type, initializer = null) {
  method constructor (line 1263) | constructor(io) {
  method toString (line 1274) | toString() {
  method constructor (line 1281) | constructor(dimensions = []) {
  method toString (line 1285) | toString() {
  method constructor (line 1295) | constructor(message) {
  method open (line 1303) | static open(data /* , target */) {
  method constructor (line 1307) | constructor(data) {
  method read (line 1311) | async read() {
  method constructor (line 1318) | constructor() {
  method open (line 1328) | static open(data /* , target */) {
  method constructor (line 1332) | constructor(data) {
  method read (line 1336) | async read() {
  method constructor (line 1343) | constructor() {

FILE: source/flatbuffers.js
  method open (line 6) | static open(data, offset) {
  method bool (line 47) | bool(offset) {
  method bool_ (line 51) | bool_(position, offset, defaultValue) {
  method int8 (line 56) | int8(offset) {
  method int8_ (line 60) | int8_(position, offset, defaultValue) {
  method uint8_ (line 65) | uint8_(position, offset, defaultValue) {
  method int16_ (line 70) | int16_(position, offset, defaultValue) {
  method uint16_ (line 75) | uint16_(position, offset, defaultValue) {
  method int32_ (line 80) | int32_(position, offset, defaultValue) {
  method uint32_ (line 85) | uint32_(position, offset, defaultValue) {
  method int64_ (line 90) | int64_(position, offset, defaultValue) {
  method uint64_ (line 95) | uint64_(position, offset, defaultValue) {
  method float32_ (line 100) | float32_(position, offset, defaultValue) {
  method float64_ (line 105) | float64_(position, offset, defaultValue) {
  method string (line 110) | string(offset, encoding) {
  method string_ (line 148) | string_(position, offset, defaultValue) {
  method bools_ (line 153) | bools_(position, offset) {
  method int64s_ (line 167) | int64s_(position, offset) {
  method uint64s_ (line 181) | uint64s_(position, offset) {
  method strings_ (line 195) | strings_(position, offset) {
  method struct (line 209) | struct(position, offset, type) {
  method table (line 214) | table(position, offset, type) {
  method union (line 219) | union(position, offset, type) {
  method array (line 226) | array(position, offset, type) {
  method unions (line 237) | unions(/* position, offset, decode */) {
  method structs (line 241) | structs(position, offset, type, size) {
  method tables (line 251) | tables(position, offset, type) {
  method __offset (line 261) | __offset(bb_pos, vtableOffset) {
  method __indirect (line 266) | __indirect(offset) {
  method __vector (line 270) | __vector(offset) {
  method __vector_len (line 274) | __vector_len(offset) {
  method __union (line 278) | __union(offset) {
  method constructor (line 285) | constructor(data) {
  method read (line 292) | read(offset, length) {
  method uint8 (line 296) | uint8(offset) {
  method int16 (line 300) | int16(offset) {
  method uint16 (line 304) | uint16(offset) {
  method int32 (line 308) | int32(offset) {
  method uint32 (line 312) | uint32(offset) {
  method int64 (line 316) | int64(offset) {
  method uint64 (line 320) | uint64(offset) {
  method float32 (line 324) | float32(offset) {
  method float64 (line 328) | float64(offset) {
  method constructor (line 335) | constructor(stream) {
  method length (line 348) | get length() {
  method read (line 352) | read(offset, length) {
  method uint8 (line 358) | uint8(offset) {
  method int16 (line 363) | int16(offset) {
  method uint16 (line 368) | uint16(offset) {
  method int32 (line 373) | int32(offset) {
  method uint32 (line 378) | uint32(offset) {
  method int64 (line 383) | int64(offset) {
  method uint64 (line 388) | uint64(offset) {
  method float32 (line 393) | float32(offset) {
  method float64 (line 398) | float64(offset) {
  method _fill (line 403) | _fill(offset, length) {
  method _read (line 440) | _read(buffer, offset) {
  method open (line 457) | static open(obj) {
  method constructor (line 461) | constructor(obj) {
  method root (line 465) | get root() {
  method int64 (line 469) | int64(obj, defaultValue) {
  method uint64 (line 473) | uint64(obj, defaultValue) {
  method value (line 477) | value(obj, defaultValue) {
  method object (line 481) | object(obj, type) {
  method array (line 485) | array(obj, type) {
  method objects (line 501) | objects(obj, type) {
  method constructor (line 518) | constructor(message) {

FILE: source/flax.js
  method match (line 10) | async match(context) {
  method open (line 21) | async open(context) {
  method constructor (line 48) | constructor(obj) {
  method constructor (line 56) | constructor(obj) {
  method constructor (line 94) | constructor(name, value) {
  method constructor (line 102) | constructor(name, initializer = null) {
  method constructor (line 114) | constructor(name, layer) {
  method constructor (line 138) | constructor(dataType, shape) {
  method toString (line 143) | toString() {
  method constructor (line 150) | constructor(dimensions) {
  method toString (line 154) | toString() {
  method constructor (line 162) | constructor(array) {
  method values (line 170) | get values() {
  method isTensor (line 196) | static isTensor(obj) {
  method constructor (line 203) | constructor(message) {

FILE: source/flexbuffers.js
  method open (line 6) | static open(buffer) {
  method constructor (line 18) | constructor(buffer, offset, parentWidth, byteWidth, type) {
  method read (line 26) | read() {
  method length (line 30) | get length() {
  method int (line 34) | int(offset, size) {
  method uint (line 44) | uint(offset, size) {
  method float (line 54) | float(offset, size) {
  method string (line 62) | string(offset, size) {
  method bytes (line 69) | bytes(offset, size) {
  method constructor (line 76) | constructor(reader, offset, parentWidth, byteWidth, type) {
  method read (line 84) | read() {
  method _indirect (line 160) | _indirect() {
  method _vector (line 164) | _vector(offset, byteWidth) {
  method _typedVector (line 176) | _typedVector(offset, byteWidth, type, size) {
  method constructor (line 189) | constructor(message) {

FILE: source/flux.js
  method match (line 8) | async match(context) {
  method open (line 18) | async open(context) {
  method constructor (line 58) | constructor(/* root */) {
  method constructor (line 66) | constructor(message) {

FILE: source/gguf.js
  method match (line 6) | async match(context) {
  method open (line 14) | async open(context) {
  method constructor (line 24) | constructor(metadata, target) {
  method constructor (line 77) | constructor(graph) {
  method constructor (line 360) | constructor(name, value) {
  method constructor (line 368) | constructor(name, type, initializer) {
  method constructor (line 378) | constructor(layer) {
  method constructor (line 403) | constructor(dataType, shape) {
  method toString (line 408) | toString() {
  method constructor (line 415) | constructor(dimensions) {
  method toString (line 419) | toString() {
  method constructor (line 426) | constructor(tensor) {
  method values (line 441) | get values() {
  method open (line 451) | static open(context) {
  method constructor (line 463) | constructor(context) {
  method read (line 511) | async read() {
  method constructor (line 564) | constructor(reader) {
  method length (line 568) | get length() {
  method position (line 572) | get position() {
  method seek (line 576) | seek(position) {
  method skip (line 580) | skip(offset) {
  method stream (line 584) | stream(length) {
  method read (line 588) | read(length) {
  method byte (line 592) | byte() {
  method int8 (line 596) | int8() {
  method uint16 (line 600) | uint16() {
  method int16 (line 604) | int16() {
  method uint32 (line 608) | uint32() {
  method int32 (line 612) | int32() {
  method uint64 (line 616) | uint64() {
  method int64 (line 620) | int64() {
  method float32 (line 624) | float32() {
  method float64 (line 628) | float64() {
  method string (line 632) | string() {
  method value (line 638) | value(type) {
  method entry (line 667) | entry() {
  method tensor (line 674) | tensor() {
  method constructor (line 750) | constructor(metadata, target, kvMetadata, architecture) {
  method structured (line 784) | get structured() {
  method build (line 788) | build() {
  method _buildFlat (line 950) | _buildFlat() {
  method _classifyTensor (line 1071) | _classifyTensor(name) {
  method enum (line 1133) | static enum(type, value) {
  method constructor (line 1149) | constructor(message) {

FILE: source/grapher.js
  method constructor (line 6) | constructor(compound) {
  method setNode (line 17) | setNode(node) {
  method setEdge (line 32) | setEdge(edge) {
  method setParent (line 45) | setParent(node, parent) {
  method nodes (line 61) | get nodes() {
  method hasNode (line 65) | hasNode(key) {
  method node (line 69) | node(key) {
  method edge (line 73) | edge(v, w) {
  method edges (line 77) | get edges() {
  method parent (line 81) | parent(key) {
  method children (line 91) | children(key) {
  method build (line 106) | build(document, origin) {
  method measure (line 213) | async measure() {
  method layout (line 225) | async layout(worker) {
  method update (line 338) | update() {
  method constructor (line 364) | constructor() {
  method header (line 368) | header() {
  method list (line 374) | list() {
  method canvas (line 380) | canvas() {
  method build (line 386) | build(document, parent) {
  method measure (line 405) | async measure() {
  method layout (line 418) | async layout() {
  method update (line 430) | update() {
  method select (line 439) | select() {
  method deselect (line 447) | deselect() {
  method roundedRect (line 453) | static roundedRect(x, y, width, height, r1, r2, r3, r4) {
  method constructor (line 465) | constructor() {
  method add (line 469) | add(id, classes) {
  method build (line 475) | build(document, parent) {
  method measure (line 493) | measure() {
  method layout (line 503) | layout() {
  method update (line 517) | update() {
  method constructor (line 541) | constructor(id, classes) {
  method on (line 547) | on(event, callback) {
  method emit (line 552) | emit(event, data) {
  method build (line 560) | build(document, parent) {
  method measure (line 589) | measure() {
  method layout (line 599) | layout() {
  method constructor (line 605) | constructor() {
  method argument (line 610) | argument(name, value) {
  method add (line 614) | add(value) {
  method on (line 618) | on(event, callback) {
  method emit (line 623) | emit(event, data) {
  method build (line 631) | build(document, parent) {
  method measure (line 654) | async measure() {
  method layout (line 676) | async layout() {
  method update (line 689) | update() {
  method constructor (line 706) | constructor(name, content) {
  method build (line 718) | build(document, parent) {
  method measure (line 781) | async measure() {
  method layout (line 805) | async layout() {
  method update (line 827) | update() {
  method select (line 846) | select() {
  method deselect (line 854) | deselect() {
  method constructor (line 863) | constructor() {
  method build (line 868) | build(/* document, parent */) {
  method update (line 871) | update(/* parent, top, width , first, last */) {
  method constructor (line 877) | constructor(from, to) {
  method build (line 882) | build(document, edgePathGroupElement, edgePathHitTestGroupElement, edgeL...
  method update (line 915) | update() {
  method select (line 952) | select() {
  method deselect (line 965) | deselect() {
  method constructor (line 977) | constructor(points) {
  method path (line 1007) | get path() {
  method point (line 1011) | point(x, y) {
  method curve (line 1041) | curve(x, y) {
  method constructor (line 1055) | constructor() {
  method moveTo (line 1063) | moveTo(x, y) {
  method lineTo (line 1071) | lineTo(x, y) {
  method bezierCurveTo (line 1077) | bezierCurveTo(x1, y1, x2, y2, x, y) {
  method closePath (line 1083) | closePath() {
  method data (line 1091) | get data() {

FILE: source/hailo.js
  method match (line 7) | async match(context) {
  method filter (line 15) | filter(context, match) {
  method open (line 25) | async open(context) {
  method constructor (line 35) | constructor(metadata, container) {
  method constructor (line 49) | constructor(metadata, configuration, weights) {
  method constructor (line 111) | constructor(name, value, type = null, visible = true) {
  method constructor (line 121) | constructor(name, type, initializer) {
  method constructor (line 133) | constructor(metadata, layer, values, weights) {
  method constructor (line 196) | constructor(array, shape) {
  method constructor (line 210) | constructor(dataType, shape) {
  method equals (line 215) | equals(obj) {
  method toString (line 219) | toString() {
  method constructor (line 226) | constructor(dimensions) {
  method equals (line 230) | equals(obj) {
  method toString (line 244) | toString() {
  method open (line 254) | static async open(context) {
  method constructor (line 276) | constructor(context, type, basename, configuration, metadata) {
  method _request (line 284) | async _request(name, type) {
  method read (line 296) | async read() {
  method constructor (line 346) | constructor(message) {

FILE: source/hdf5.js
  method open (line 10) | static open(data) {
  method constructor (line 21) | constructor(data) {
  method read (line 25) | read() {
  method constructor (line 83) | constructor(reader, entry, objectHeader, globalHeap, parentPath, name) {
  method name (line 92) | get name() {
  method path (line 96) | get path() {
  method group (line 100) | group(path) {
  method groups (line 115) | get groups() {
  method attributes (line 120) | get attributes() {
  method value (line 125) | get value() {
  method _decodeDataObject (line 130) | _decodeDataObject() {
  method _decodeGroups (line 155) | _decodeGroups() {
  method constructor (line 187) | constructor(reader, globalHeap, datatype, dataspace, dataLayout, filterP...
  method type (line 196) | get type () {
  method littleEndian (line 200) | get littleEndian() {
  method shape (line 204) | get shape() {
  method value (line 208) | get value() {
  method data (line 218) | get data() {
  method open (line 306) | static open(data) {
  method initialize (line 318) | initialize() {
  method int8 (line 323) | int8() {
  method byte (line 328) | byte() {
  method int16 (line 333) | int16() {
  method uint16 (line 338) | uint16() {
  method int32 (line 343) | int32() {
  method uint32 (line 348) | uint32() {
  method int64 (line 353) | int64() {
  method uint64 (line 358) | uint64() {
  method uint (line 363) | uint(size) {
  method float16 (line 373) | float16() {
  method float32 (line 388) | float32() {
  method float64 (line 393) | float64() {
  method offset (line 398) | offset() {
  method length (line 424) | length() {
  method string (line 450) | string(size, encoding) {
  method match (line 471) | match(signature) {
  method expect (line 482) | expect(signature) {
  method constructor (line 491) | constructor(buffer, view, offset, position, offsetSize, lengthSize) {
  method position (line 502) | get position() {
  method take (line 506) | take(offset) {
  method seek (line 512) | seek(position) {
  method skip (line 520) | skip(offset) {
  method align (line 527) | align(mod) {
  method peek (line 533) | peek(length) {
  method read (line 542) | read(length) {
  method stream (line 547) | stream(length) {
  method size (line 553) | size(terminator) {
  method constructor (line 564) | constructor(stream, view, window, offset, position, offsetSize, lengthSi...
  method position (line 576) | get position() {
  method seek (line 580) | seek(position) {
  method skip (line 588) | skip(offset) {
  method align (line 595) | align(mod) {
  method read (line 601) | read(length) {
  method stream (line 610) | stream(length) {
  method byte (line 619) | byte() {
  method uint16 (line 624) | uint16() {
  method int32 (line 629) | int32() {
  method uint32 (line 634) | uint32() {
  method int64 (line 639) | int64() {
  method float32 (line 644) | float32() {
  method float64 (line 649) | float64() {
  method size (line 654) | size(terminator) {
  method take (line 664) | take(length) {
  method constructor (line 684) | constructor(reader, offset) {
  method constructor (line 706) | constructor(reader) {
  method constructor (line 730) | constructor(reader, offset) {
  method _readMessage (line 807) | _readMessage(reader, type, size, flags) {
  method constructor (line 867) | constructor(type, data, flags) {
  method constructor (line 876) | constructor(reader) {
  method shape (line 921) | get shape() {
  method read (line 925) | read(datatype, reader) {
  method _readArray (line 932) | _readArray(datatype, reader, shape, dimension) {
  method decode (line 947) | decode(datatype, data, globalHeap) {
  method _decodeArray (line 954) | _decodeArray(datatype, data, globalHeap, shape, dimension) {
  method constructor (line 971) | constructor(reader) {
  method constructor (line 994) | constructor(reader) {
  method type (line 1037) | get type() {
  method littleEndian (line 1093) | get littleEndian() {
  method read (line 1103) | read(reader) {
  method decode (line 1148) | decode(data, globalHeap) {
  method constructor (line 1185) | constructor(reader, type) {
  method constructor (line 1227) | constructor(reader) {
  method constructor (line 1259) | constructor(reader) {
  method constructor (line 1324) | constructor(reader) {
  method constructor (line 1347) | constructor(reader) {
  method constructor (line 1370) | constructor(reader) {
  method decode (line 1379) | decode(data) {
  method _deflate (line 1387) | _deflate(input) {
  method _lzf (line 1392) | _lzf(input) {
  method constructor (line 1450) | constructor(reader) {
  method decodeValue (line 1496) | decodeValue(globalHeap) {
  method constructor (line 1506) | constructor(reader) {
  method constructor (line 1514) | constructor(reader) {
  method constructor (line 1522) | constructor(reader, type) {
  method constructor (line 1556) | constructor(reader) {
  method constructor (line 1579) | constructor(reader, offset, dimensionality) {
  method constructor (line 1637) | constructor(reader, offset) {
  method getString (line 1658) | getString(offset) {
  method constructor (line 1669) | constructor(reader) {
  method get (line 1674) | get(globalHeapID) {
  method constructor (line 1686) | constructor(reader, offset) {
  method getObject (line 1715) | getObject(objectIndex) {
  method constructor (line 1725) | constructor(reader) {
  method reader (line 1734) | reader() {
  method constructor (line 1742) | constructor(reader) {
  method constructor (line 1750) | constructor(message) {

FILE: source/hickle.js
  method match (line 6) | async match(context) {
  method open (line 14) | async open(context) {
  method constructor (line 21) | constructor(group) {
  method constructor (line 29) | constructor(group) {
  method constructor (line 84) | constructor(name, value) {
  method constructor (line 92) | constructor(name, type, initializer = null) {
  method constructor (line 104) | constructor(name, parameters) {
  method constructor (line 119) | constructor(name, shape, type, littleEndian, data) {
  method values (line 126) | get values() {
  method constructor (line 139) | constructor(dataType, shape) {
  method toString (line 144) | toString() {
  method constructor (line 151) | constructor(dimensions) {
  method toString (line 155) | toString() {
  method constructor (line 162) | constructor(message) {

FILE: source/imgdnn.js
  method match (line 6) | async match(context) {
  method open (line 15) | open(/* context */) {
  method constructor (line 22) | constructor(metadata, model) {
  method constructor (line 30) | constructor(/* metadata, model */) {
  method constructor (line 39) | constructor(message) {

FILE: source/json.js
  method open (line 9) | static open(data) {
  method constructor (line 60) | constructor(decoder) {
  method read (line 66) | read() {
  method _next (line 229) | _next() {
  method _whitespace (line 237) | _whitespace() {
  method _literal (line 243) | _literal() {
  method _number (line 260) | _number() {
  method _string (line 320) | _string() {
  method _expect (line 355) | _expect(value) {
  method _unexpected (line 364) | _unexpected() {
  method _location (line 382) | _location() {
  method open (line 406) | static open(data) {
  method constructor (line 420) | constructor(data, format) {
  method read (line 425) | read() {
  method _readBson (line 436) | _readBson() {
  method _readUbj (line 579) | _readUbj() {
  method constructor (line 586) | constructor(message) {
  method constructor (line 594) | constructor(message) {

FILE: source/kann-schema.js
  method identifier (line 6) | static identifier(reader) {
  method create (line 10) | static create(reader) {
  method decode (line 14) | static decode(reader, position) {
  method decode (line 23) | static decode(reader, position) {
  method decode (line 35) | static decode(reader, position) {
  method decode (line 46) | static decode(reader, position) {
  method decode (line 62) | static decode(reader, position) {
  method decode (line 76) | static decode(reader, position) {
  method decode (line 88) | static decode(reader, position) {

FILE: source/kann.js
  method match (line 6) | async match(context) {
  method open (line 14) | async open(context) {
  method constructor (line 40) | constructor(metadata, model, identifier) {
  method constructor (line 49) | constructor(metadata, graph) {
  method constructor (line 62) | constructor(metadata, node, arcs) {
  method constructor (line 137) | constructor(name, value, type = null) {
  method constructor (line 146) | constructor(name, type, initializer) {
  method constructor (line 156) | constructor(name, type, values, quantization) {
  method constructor (line 167) | constructor(dataType, shape) {
  method toString (line 172) | toString() {
  method constructor (line 179) | constructor(dimensions) {
  method toString (line 183) | toString() {
  method constructor (line 193) | constructor(message) {

FILE: source/keras-proto.js
  method constructor (line 14) | constructor() {
  method decode (line 18) | static decode(reader, length) {
  method decodeText (line 35) | static decodeText(reader) {
  method decode (line 55) | static decode(reader, length) {
  method decodeText (line 84) | static decodeText(reader) {
  method constructor (line 122) | constructor() {
  method decode (line 126) | static decode(reader, length) {
  method decodeText (line 149) | static decodeText(reader) {

FILE: source/keras.js
  method match (line 10) | async match(context) {
  method filter (line 66) | filter(context, match) {
  method open (line 79) | async open(context) {
  method constructor (line 517) | constructor(metadata, format, producer, backend, config, weights) {
  method constructor (line 528) | constructor(metadata, config, weights, group) {
  method constructor (line 886) | constructor(name, value, type = null, visible = true) {
  method constructor (line 896) | constructor(name, type, initializer = null) {
  method constructor (line 909) | constructor(metadata, layer, group, weights, values) {
  method constructor (line 1194) | constructor(name, shape, type, stride, quantization, encoding, data, loc...
  method values (line 1210) | get values() {
  method constructor (line 1223) | constructor(dataType, shape) {
  method toString (line 1228) | toString() {
  method constructor (line 1235) | constructor(dimensions) {
  method toString (line 1239) | toString() {
  method constructor (line 1246) | constructor(metadata) {
  method type (line 1251) | type(name) {
  method attribute (line 1258) | attribute(type, name) {
  method add (line 1262) | add(type, metadata) {
  method constructor (line 1269) | constructor() {
  method empty (line 1273) | get empty() {
  method add (line 1277) | add(layer_name, tensor) {
  method get (line 1284) | get(group, name) {
  method keys (line 1313) | keys() {
  method constructor (line 1320) | constructor(message) {
  method open (line 1328) | static async open(context) {
  method constructor (line 1348) | constructor(context, type) {
  method read (line 1353) | async read() {
  method _openShards (line 1390) | _openShards(manifests, shards) {
  method _openManifests (line 1428) | async _openManifests(manifests) {
  method _openModelJson (line 1453) | _openModelJson(obj) {
  method constructor (line 1482) | constructor(message) {

FILE: source/kmodel.js
  method match (line 8) | async match(context) {
  method open (line 16) | async open(context) {
  method constructor (line 25) | constructor(model) {
  method constructor (line 33) | constructor(module) {
  method constructor (line 124) | constructor(name, value) {
  method constructor (line 132) | constructor(name, type, initializer) {
  method constructor (line 144) | constructor(dataType, shape) {
  method equals (line 149) | equals(obj) {
  method toString (line 153) | toString() {
  method constructor (line 160) | constructor(dimensions) {
  method equals (line 164) | equals(obj) {
  method toString (line 178) | toString() {
  method constructor (line 188) | constructor(type, data) {
  method constructor (line 196) | constructor(layer, value) {
  method open (line 231) | static open(stream) {
  method constructor (line 248) | constructor(stream, version) {
  method read (line 254) | read() {
  method constructor (line 1160) | constructor(data) {
  method position (line 1164) | get position() {
  method seek (line 1168) | seek(position) {
  method skip (line 1172) | skip(offset) {
  method align (line 1176) | align(size) {
  method read (line 1180) | read(length) {
  method boolean (line 1184) | boolean() {
  method byte (line 1188) | byte() {
  method int8 (line 1192) | int8() {
  method int16 (line 1196) | int16() {
  method int32 (line 1200) | int32() {
  method uint16 (line 1204) | uint16() {
  method uint32 (line 1208) | uint32() {
  method uint64 (line 1212) | uint64() {
  method float32 (line 1216) | float32() {
  method uint64_bits (line 1220) | uint64_bits(fields) {
  method constructor (line 1247) | constructor(buffer) {
  method kpu_model_header_t (line 1252) | kpu_model_header_t() {
  method kpu_model_output_t (line 1263) | kpu_model_output_t(name) {
  method kpu_model_layer_header_t (line 1270) | kpu_model_layer_header_t() {
  method argument (line 1277) | argument(memory_type) {
  method parameter (line 1283) | parameter(name, memory_type) {
  method constructor (line 1290) | constructor(buffer) {
  method memory_type_t (line 1297) | memory_type_t() {
  method datatype_t (line 1302) | datatype_t() {
  method memory_range (line 1307) | memory_range() {
  method argument (line 1316) | argument() {
  method parameter (line 1333) | parameter(name) {
  method runtime_shape_t (line 1337) | runtime_shape_t() {
  method padding (line 1341) | padding() {
  method runtime_paddings_t (line 1345) | runtime_paddings_t() {
  method scalar (line 1349) | scalar() {
  method kpu_activate_table_t (line 1356) | kpu_activate_table_t() {
  method unary_op_t (line 1369) | unary_op_t() {
  method binary_op_t (line 1374) | binary_op_t() {
  method reduce_op_t (line 1379) | reduce_op_t() {
  method image_resize_mode_t (line 1384) | image_resize_mode_t() {
  method constants (line 1389) | constants(size) {
  method span (line 1393) | span(datatype, shape) {
  method constructor (line 1411) | constructor(buffer) {
  method model_header (line 1418) | model_header() {
  method module_type_t (line 1437) | module_type_t() {
  method module_header (line 1444) | module_header() {
  method mempool_desc (line 1463) | mempool_desc() {
  method section_header (line 1471) | section_header() {
  method function_header (line 1484) | function_header() {
  method memory_location_t (line 1503) | memory_location_t() {
  method datatype_t (line 1511) | datatype_t() {
  method memory_range (line 1516) | memory_range() {
  method argument (line 1526) | argument() {
  method parameter (line 1545) | parameter(name) {
  method shape (line 1549) | shape() {
  method model_header (line 1560) | model_header() {
  method module_header (line 1571) | module_header() {
  method function_header (line 1581) | function_header() {
  method section_header (line 1592) | section_header() {
  method deserialize_datatype (line 1607) | deserialize_datatype() {
  method deserialize_type (line 1623) | deserialize_type() {
  method peek (line 1663) | peek() {
  method module_header (line 1672) | module_header() {
  method function_header (line 1683) | function_header() {
  method section_header (line 1693) | section_header() {
  method constructor (line 1711) | constructor(buffer) {
  method read (line 1715) | read() {
  method strings (line 1735) | strings() {
  method constructor (line 1754) | constructor(buffer) {
  method operation (line 1822) | operation(operation) {
  method string (line 1887) | string() {
  method tensor (line 1898) | tensor(operation) {
  method constructor (line 2061) | constructor(reader) {
  method operation (line 2187) | operation(operation) {
  method tensor (line 2208) | tensor(operation) {
  method constructor (line 2243) | constructor(message) {

FILE: source/lasagne.js
  method match (line 8) | async match(context) {
  method open (line 16) | async open(context) {
  method constructor (line 24) | constructor(metadata, model) {
  method constructor (line 32) | constructor(metadata, model) {
  method constructor (line 77) | constructor(name, value, type = null) {
  method constructor (line 86) | constructor(name, type, initializer) {
  method constructor (line 98) | constructor(metadata, layer, values) {
  method constructor (line 139) | constructor(dataType, shape) {
  method equals (line 144) | equals(obj) {
  method toString (line 148) | toString() {
  method constructor (line 155) | constructor(dimensions) {
  method equals (line 159) | equals(obj) {
  method toString (line 165) | toString() {
  method constructor (line 175) | constructor(storage) {
  method constructor (line 183) | constructor(message) {

FILE: source/lightgbm.js
  method match (line 8) | async match(context) {
  method open (line 21) | async open(context) {
  method constructor (line 46) | constructor(obj, format) {
  method constructor (line 54) | constructor(model) {
  method constructor (line 77) | constructor(name, value, type = null) {
  method constructor (line 86) | constructor(name) {
  method constructor (line 96) | constructor(obj, values, stack) {
  method constructor (line 144) | constructor(message) {

FILE: source/mediapipe.js
  method match (line 8) | async match(context) {
  method open (line 16) | async open(context) {
  method constructor (line 34) | constructor(config) {
  method constructor (line 42) | constructor(config) {
  method constructor (line 116) | constructor(node, value) {
  method constructor (line 188) | constructor(name, value) {
  method constructor (line 196) | constructor(name, type = null) {
  method constructor (line 207) | constructor(reader, block) {
  method constructor (line 280) | constructor(message) {

FILE: source/megengine-schema.js
  method decode (line 34) | static decode(reader, position) {
  method decode (line 44) | static decode(reader, position, type) {
  method decode (line 54) | static decode(reader, position) {
  method decode (line 557) | static decode(/* reader, position */) {
  method decode (line 565) | static decode(reader, position) {
  method decode (line 574) | static decode(reader, position) {
  method decode (line 592) | static decode(reader, position) {
  method decode (line 610) | static decode(reader, position) {
  method decode (line 628) | static decode(reader, position) {
  method decode (line 644) | static decode(reader, position) {
  method decode (line 666) | static decode(reader, position) {
  method decode (line 680) | static decode(reader, position) {
  method decode (line 699) | static decode(reader, position) {
  method decode (line 718) | static decode(reader, position) {
  method decode (line 738) | static decode(reader, position) {
  method decode (line 757) | static decode(reader, position) {
  method decode (line 776) | static decode(reader, position) {
  method decode (line 792) | static decode(reader, position) {
  method decode (line 810) | static decode(reader, position) {
  method decode (line 826) | static decode(reader, position) {
  method decode (line 842) | static decode(reader, position) {
  method decode (line 851) | static decode(reader, position) {
  method decode (line 861) | static decode(reader, position) {
  method decode (line 871) | static decode(reader, position) {
  method decode (line 883) | static decode(reader, position) {
  method decode (line 897) | static decode(reader, position) {
  method decode (line 907) | static decode(reader, position) {
  method decode (line 919) | static decode(reader, position) {
  method decode (line 931) | static decode(reader, position) {
  method decode (line 940) | static decode(reader, position) {
  method decode (line 949) | static decode(reader, position) {
  method decode (line 960) | static decode(reader, position) {
  method decode (line 969) | static decode(reader, position) {
  method decode (line 978) | static decode(reader, position) {
  method decode (line 987) | static decode(reader, position) {
  method decode (line 998) | static decode(reader, position) {
  method decode (line 1009) | static decode(reader, position) {
  method decode (line 1020) | static decode(reader, position) {
  method decode (line 1031) | static decode(reader, position) {
  method decode (line 1043) | static decode(reader, position) {
  method decode (line 1053) | static decode(reader, position) {
  method decode (line 1063) | static decode(reader, position) {
  method decode (line 1074) | static decode(reader, position) {
  method decode (line 1085) | static decode(reader, position) {
  method decode (line 1096) | static decode(reader, position) {
  method decode (line 1107) | static decode(reader, position) {
  method decode (line 1118) | static decode(reader, position) {
  method decode (line 1127) | static decode(reader, position) {
  method decode (line 1136) | static decode(reader, position) {
  method decode (line 1145) | static decode(reader, position) {
  method decode (line 1154) | static decode(reader, position) {
  method decode (line 1165) | static decode(reader, position) {
  method decode (line 1175) | static decode(reader, position) {
  method decode (line 1184) | static decode(reader, position) {
  method decode (line 1193) | static decode(reader, position) {
  method decode (line 1203) | static decode(reader, position) {
  method decode (line 1214) | static decode(reader, position) {
  method decode (line 1226) | static decode(reader, position) {
  method decode (line 1235) | static decode(reader, position) {
  method decode (line 1244) | static decode(reader, position) {
  method decode (line 1253) | static decode(reader, position) {
  method decode (line 1264) | static decode(reader, position) {
  method decode (line 1274) | static decode(reader, position) {
  method decode (line 1283) | static decode(reader, position) {
  method decode (line 1293) | static decode(reader, position) {
  method decode (line 1302) | static decode(reader, position) {
  method decode (line 1314) | static decode(reader, position) {
  method decode (line 1323) | static decode(reader, position) {
  method decode (line 1334) | static decode(reader, position) {
  method decode (line 1346) | static decode(reader, position) {
  method decode (line 1358) | static decode(reader, position) {
  method decode (line 1371) | static decode(reader, position) {
  method decode (line 1380) | static decode(reader, position) {
  method decode (line 1390) | static decode(reader, position) {
  method decode (line 1400) | static decode(reader, position) {
  method decode (line 1412) | static decode(reader, position) {
  method decode (line 1424) | static decode(reader, position) {
  method decode (line 1445) | static decode(reader, position) {
  method decode (line 1461) | static decode(reader, position) {
  method decode (line 1484) | static decode(reader, position) {
  method decode (line 1493) | static decode(reader, position) {
  method decode (line 1502) | static decode(reader, position) {
  method decode (line 1513) | static decode(reader, position) {
  method decode (line 1528) | static decode(reader, position) {
  method decode (line 1543) | static decode(reader, position) {
  method decode (line 1563) | static decode(reader, position) {
  method decode (line 1583) | static decode(reader, position) {
  method decode (line 1599) | static decode(reader, position) {
  method decode (line 1615) | static decode(reader, position) {
  method decode (line 1630) | static decode(reader, position) {
  method decode (line 1645) | static decode(reader, position) {
  method decode (line 1664) | static decode(reader, position) {
  method decode (line 1683) | static decode(reader, position) {
  method decode (line 1693) | static decode(reader, position) {
  method decode (line 1703) | static decode(reader, position) {
  method decode (line 1713) | static decode(reader, position) {
  method decode (line 1722) | static decode(reader, position) {
  method decode (line 1731) | static decode(reader, position) {
  method decode (line 1755) | static decode(reader, position) {
  method decode (line 1767) | static decode(reader, position) {
  method decode (line 1779) | static decode(reader, position) {
  method decode (line 1789) | static decode(reader, position) {
  method decode (line 1798) | static decode(reader, position) {
  method decode (line 1813) | static decode(reader, position) {
  method decode (line 1890) | static decode(reader, position) {
  method decode (line 1899) | static decode(reader, position) {
  method decode (line 1908) | static decode(reader, position) {
  method decode (line 1917) | static decode(reader, position) {
  method decode (line 1926) | static decode(reader, position) {
  method decode (line 1936) | static decode(reader, position) {
  method decode (line 1946) | static decode(reader, position) {
  method decode (line 1956) | static decode(reader, position) {
  method decode (line 1974) | static decode(reader, position) {
  method decode (line 1983) | static decode(/* reader, position */) {
  method decode (line 1991) | static decode(reader, position) {
  method decode (line 2001) | static decode(reader, position) {
  method decode (line 2010) | static decode(reader, position) {
  method decode (line 2020) | static decode(reader, position) {
  method decode (line 2030) | static decode(reader, position) {
  method decode (line 2039) | static decode(reader, position) {
  method decode (line 2049) | static decode(reader, position) {
  method decode (line 2060) | static decode(reader, position) {
  method decode (line 2071) | static decode(reader, position) {
  method decode (line 20

Copy disabled (too large) Download .json

Condensed preview — 252 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (17,925K chars).

[
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.md",
    "chars": 362,
    "preview": "---\nname: Bug report\nabout: Create a report to help us improve\nlabels: bug\n---\n\n- Netron app and version: <!-- For examp"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature_request.md",
    "chars": 197,
    "preview": "---\nname: Feature request\nabout: Suggest an idea for this project\nlabels: feature\n---\n<!-- Please search existing issues"
  },
  {
    "path": ".github/workflows/build.yml",
    "chars": 1781,
    "preview": "\nname: Build\n\non:\n  push:\n    branches: [ '**' ]\n    tags-ignore: [ '**' ]\n  pull_request:\n    branches: [ main ]\n\njobs:"
  },
  {
    "path": ".github/workflows/publish.yml",
    "chars": 3010,
    "preview": "\nname: Publish\n\non:\n  push:\n    tags: [ 'v**' ]\n\njobs:\n  publish:\n    runs-on: ${{ matrix.os }}\n\n    strategy:\n      mat"
  },
  {
    "path": ".gitignore",
    "chars": 136,
    "preview": ".DS_Store\n.DS_Store?\n.claude\n.eslintcache\n.ruff_cache\n.specify\n.yarn\ndist/*\nnode_modules/*\ntest-results/*\nthird_party/*\n"
  },
  {
    "path": ".npmrc",
    "chars": 15,
    "preview": "loglevel=silent"
  },
  {
    "path": ".vscode/launch.json",
    "chars": 3673,
    "preview": "{\n    \"version\": \"0.2.0\",\n    \"configurations\": [\n        {\n            \"name\": \"Desktop View\",\n            \"type\": \"chr"
  },
  {
    "path": ".vscode/settings.json",
    "chars": 259,
    "preview": "{\n    \"eslint.lintTask.enable\": true,\n    \"files.exclude\": {\n        \"dist\": true,\n        \"node_modules\": true,\n       "
  },
  {
    "path": "CITATION.cff",
    "chars": 470,
    "preview": "cff-version: 1.2.0\ntitle: \"Netron, Visualizer for neural network, deep learning, and machine learning models\"\nauthors:\n-"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 767,
    "preview": "# How to Develop Netron\n\n## Debugging\n\nNetron can run as both an [Electron](https://electronjs.org) app or a web app.\n\nT"
  },
  {
    "path": "LICENSE",
    "chars": 1062,
    "preview": "MIT License\n\nCopyright (c) Lutz Roeder\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof "
  },
  {
    "path": "README.md",
    "chars": 3348,
    "preview": "<div align=\"center\">\n<img width=\"400px\" height=\"100px\" src=\"https://github.com/lutzroeder/netron/raw/main/.github/logo-l"
  },
  {
    "path": "eslint.config.js",
    "chars": 9965,
    "preview": "\nexport default [\n    {\n        ignores: [\n            'dist/**',\n            'third_party/**',\n        ]\n    },\n    {\n "
  },
  {
    "path": "package.js",
    "chars": 28694,
    "preview": "\nimport * as child_process from 'child_process';\nimport * as crypto from 'crypto';\nimport * as fs from 'fs/promises';\nim"
  },
  {
    "path": "package.json",
    "chars": 1637,
    "preview": "{\n    \"name\": \"netron\",\n    \"productName\": \"Netron\",\n    \"author\": {\n        \"name\": \"Lutz Roeder\",\n        \"email\": \"lu"
  },
  {
    "path": "package.py",
    "chars": 2265,
    "preview": "import os\nimport sys\n\nargv = sys.argv[1:]\n\nroot_dir = os.path.dirname(os.path.abspath(__file__))\ndist_dir = os.path.join"
  },
  {
    "path": "publish/electron-builder.json",
    "chars": 6155,
    "preview": "{\n    \"appId\": \"com.lutzroeder.netron\",\n    \"productName\": \"Netron\",\n    \"files\": [ \"source/**/*\" ],\n    \"directories\": "
  },
  {
    "path": "publish/icon.html",
    "chars": 1145,
    "preview": "<!DOCTYPE html>\n<html>\n<body>\n<div style=\"height: 400px;\">\n<div style=\"background: #f6f6f6; width: 400px; height: 400px;"
  },
  {
    "path": "pyproject.toml",
    "chars": 2109,
    "preview": "\n[build-system]\nrequires = [\"setuptools>=42\", \"wheel\"]\nbuild-backend = \"setuptools.build_meta\"\n\n[project]\nname = \"netron"
  },
  {
    "path": "source/__init__.py",
    "chars": 1753,
    "preview": "\"\"\" Python Server entry point \"\"\"\n\nimport argparse\nimport logging\nimport os\nimport sys\n\nfrom .server import __version__,"
  },
  {
    "path": "source/acuity-metadata.json",
    "chars": 80281,
    "preview": "[\n  {\n    \"name\": \"a_times_b_plus_c\",\n    \"inputs\": [\n      { \"name\": \"A\" },\n      { \"name\": \"B\" },\n      { \"name\": \"C\" "
  },
  {
    "path": "source/acuity.js",
    "chars": 29591,
    "preview": "\nconst acuity = {};\n\nacuity.ModelFactory = class {\n\n    async match(context) {\n        const obj = await context.peek('j"
  },
  {
    "path": "source/app.js",
    "chars": 38498,
    "preview": "\nimport * as base from './base.js';\nimport * as electron from 'electron';\nimport * as fs from 'fs';\nimport * as os from "
  },
  {
    "path": "source/armnn-metadata.json",
    "chars": 11356,
    "preview": "[\n  {\n    \"name\": \"ActivationLayer\",\n    \"category\": \"Activation\",\n    \"attributes\": [\n      { \"name\": \"activationFuncti"
  },
  {
    "path": "source/armnn-schema.js",
    "chars": 125662,
    "preview": "\nexport const armnnSerializer = {};\n\narmnnSerializer.ActivationFunction = {\n    Sigmoid: 0, '0': 'Sigmoid',\n    TanH: 1,"
  },
  {
    "path": "source/armnn.js",
    "chars": 11454,
    "preview": "\nconst armnn = {};\n\narmnn.ModelFactory = class {\n\n    async match(context) {\n        const identifier = context.identifi"
  },
  {
    "path": "source/barracuda.js",
    "chars": 15440,
    "preview": "\n// Experimental\n\nconst barracuda = {};\n\nbarracuda.ModelFactory = class {\n\n    async match(context) {\n        const stre"
  },
  {
    "path": "source/base.js",
    "chars": 53875,
    "preview": "\nconst base = {};\n\nbase.Complex = class Complex {\n\n    constructor(real, imaginary) {\n        this.real = real;\n        "
  },
  {
    "path": "source/bigdl-metadata.json",
    "chars": 2017,
    "preview": "[\n  {\n    \"name\": \"com.intel.analytics.bigdl.nn.Dropout\",\n    \"category\": \"Dropout\"\n  },\n  {\n    \"name\": \"com.intel.anal"
  },
  {
    "path": "source/bigdl-proto.js",
    "chars": 23686,
    "preview": "\nexport const com = {};\nexport const google = {};\n\ncom.intel = {};\n\ncom.intel.analytics = {};\n\ncom.intel.analytics.bigdl"
  },
  {
    "path": "source/bigdl.js",
    "chars": 11288,
    "preview": "\n// Experimental\n\nconst bigdl = {};\n\nbigdl.ModelFactory = class {\n\n    async match(context) {\n        const tags = await"
  },
  {
    "path": "source/browser.js",
    "chars": 34193,
    "preview": "\nimport * as base from './base.js';\n\nconst browser = {};\n\nbrowser.Host = class {\n\n    constructor() {\n        this._wind"
  },
  {
    "path": "source/caffe-metadata.json",
    "chars": 9505,
    "preview": "[\n  {\n    \"name\": \"Accuracy\",\n    \"inputs\": [\n      { \"name\": \"predictions\" },\n      { \"name\": \"labels\" }\n    ],\n    \"ou"
  },
  {
    "path": "source/caffe-proto.js",
    "chars": 182571,
    "preview": "\nexport const caffe = {};\n\ncaffe.BlobShape = class BlobShape {\n\n    constructor() {\n        this.dim = [];\n    }\n\n    st"
  },
  {
    "path": "source/caffe.js",
    "chars": 23747,
    "preview": "\nconst caffe = {};\n\ncaffe.ModelFactory = class {\n\n    async match(context) {\n        const identifier = context.identifi"
  },
  {
    "path": "source/caffe2-metadata.json",
    "chars": 858145,
    "preview": "[\n  {\n    \"name\": \"Abs\",\n    \"description\": \"\\nCalculates the absolute value of the given input tensor, element-wise.\\n\\"
  },
  {
    "path": "source/caffe2-proto.js",
    "chars": 59284,
    "preview": "\nexport const caffe2 = {};\n\ncaffe2.TensorProto = class TensorProto {\n\n    constructor() {\n        this.dims = [];\n      "
  },
  {
    "path": "source/caffe2.js",
    "chars": 20490,
    "preview": "\nconst caffe2 = {};\n\ncaffe2.ModelFactory = class {\n\n    async match(context) {\n        const identifier = context.identi"
  },
  {
    "path": "source/catboost-schema.js",
    "chars": 9163,
    "preview": "\nexport const NCatBoostFbs = {};\n\nNCatBoostFbs.TGuid = class TGuid {\n\n    static decode(reader, position) {\n        cons"
  },
  {
    "path": "source/catboost.js",
    "chars": 6612,
    "preview": "\nimport * as flatbuffers from './flatbuffers.js';\nimport * as python from './python.js';\n\nconst catboost = {};\n\ncatboost"
  },
  {
    "path": "source/circle-metadata.json",
    "chars": 37363,
    "preview": "[\n  {\n    \"name\": \"Add\",\n    \"attributes\": [\n      { \"name\": \"fused_activation_function\", \"type\": \"ActivationFunctionTyp"
  },
  {
    "path": "source/circle-schema.js",
    "chars": 134619,
    "preview": "\nexport const circle = {};\n\ncircle.TensorType = {\n    FLOAT32: 0, '0': 'FLOAT32',\n    FLOAT16: 1, '1': 'FLOAT16',\n    IN"
  },
  {
    "path": "source/circle.js",
    "chars": 23671,
    "preview": "\nimport * as flatbuffers from './flatbuffers.js';\nimport * as flexbuffers from './flexbuffers.js';\nimport * as zip from "
  },
  {
    "path": "source/cntk-metadata.json",
    "chars": 14194,
    "preview": "[\n  {\n    \"name\": \"Abs\",\n    \"identifier\": 8\n  },\n  {\n    \"name\": \"Acos\",\n    \"identifier\": 82\n  },\n  {\n    \"name\": \"Asi"
  },
  {
    "path": "source/cntk-proto.js",
    "chars": 11085,
    "preview": "\nexport const CNTK = {};\n\nCNTK.proto = {};\n\nCNTK.proto.NDShape = class NDShape {\n\n    constructor() {\n        this.shape"
  },
  {
    "path": "source/cntk.js",
    "chars": 42431,
    "preview": "\nconst cntk = {};\n\ncntk.ModelFactory = class {\n\n    async match(context) {\n        const stream = context.stream;\n      "
  },
  {
    "path": "source/coreml-metadata.json",
    "chars": 16025,
    "preview": "[\n  {\n    \"name\": \"activation\",\n    \"category\": \"Activation\",\n    \"description\": \"Applies specified type of activation f"
  },
  {
    "path": "source/coreml-proto.js",
    "chars": 681153,
    "preview": "\nexport const CoreML = {};\n\nCoreML.Specification = {};\n\nCoreML.Specification.Pipeline = class Pipeline {\n\n    constructo"
  },
  {
    "path": "source/coreml.js",
    "chars": 71533,
    "preview": "\nimport * as base from './base.js';\n\nconst coreml = {};\n\ncoreml.ModelFactory = class {\n\n    async match(context) {\n     "
  },
  {
    "path": "source/dagre.js",
    "chars": 104540,
    "preview": "\nconst dagre = {};\n\n// Dagre graph layout\n// https://github.com/dagrejs/dagre\n// https://github.com/dagrejs/graphlib\n\nda"
  },
  {
    "path": "source/darknet-metadata.json",
    "chars": 20540,
    "preview": "[\n  {\n    \"name\": \"avgpool\",\n    \"category\": \"Pool\"\n  },\n  {\n    \"name\": \"batchnorm\",\n    \"category\": \"Normalization\"\n  "
  },
  {
    "path": "source/darknet.js",
    "chars": 56490,
    "preview": "\nconst darknet = {};\n\ndarknet.ModelFactory = class {\n\n    async match(context) {\n        const identifier = context.iden"
  },
  {
    "path": "source/desktop.mjs",
    "chars": 24877,
    "preview": "\nimport * as base from './base.js';\nimport * as child_process from 'child_process';\nimport * as electron from 'electron'"
  },
  {
    "path": "source/dl4j-metadata.json",
    "chars": 1131,
    "preview": "[\n  {\n    \"name\": \"BatchNormalization\",\n    \"category\": \"Normalization\",\n    \"attributes\": [\n      { \"name\": \"eps\" },\n  "
  },
  {
    "path": "source/dl4j.js",
    "chars": 15419,
    "preview": "\n// Experimental\n\nconst dl4j = {};\n\ndl4j.ModelFactory = class {\n\n    async match(context) {\n        const identifier = c"
  },
  {
    "path": "source/dlc-metadata.json",
    "chars": 2344,
    "preview": "[\n  {\n    \"name\": \"BatchNorm\",\n    \"category\": \"Normalization\"\n  },\n  {\n    \"name\": \"Batchnorm\",\n    \"category\": \"Normal"
  },
  {
    "path": "source/dlc-schema.js",
    "chars": 8456,
    "preview": "\nexport const dlc = {};\n\ndlc.v3 = dlc.v3 || {};\n\ndlc.v3.Model = class Model {\n\n    static decode(reader, position) {\n   "
  },
  {
    "path": "source/dlc.js",
    "chars": 27359,
    "preview": "\nimport * as flatbuffers from './flatbuffers.js';\nimport * as text from './text.js';\n\nconst dlc = {};\n\ndlc.ModelFactory "
  },
  {
    "path": "source/dnn-metadata.json",
    "chars": 1777,
    "preview": "[\n  {\n    \"name\": \"batchnorm\",\n    \"category\": \"Normalization\",\n    \"inputs\": [\n      { \"name\": \"input\" },\n      { \"name"
  },
  {
    "path": "source/dnn-proto.js",
    "chars": 10997,
    "preview": "\nexport const dnn = {};\n\ndnn.Model = class Model {\n\n    constructor() {\n        this.input_shape = [];\n        this.inpu"
  },
  {
    "path": "source/dnn.js",
    "chars": 9040,
    "preview": "\n// Experimental\n\nconst dnn = {};\n\ndnn.ModelFactory = class {\n\n    async match(context) {\n        const tags = await con"
  },
  {
    "path": "source/dot.js",
    "chars": 22956,
    "preview": "\nconst dot = {};\n\ndot.ModelFactory = class {\n\n    async match(context) {\n        const reader = await context.read('text"
  },
  {
    "path": "source/espdl-metadata.json",
    "chars": 9024,
    "preview": "[\n  {\n    \"name\": \"Add\",\n    \"module\": \"espdl\",\n    \"version\": 1,\n    \"description\": \"Element-wise addition of two tenso"
  },
  {
    "path": "source/espdl-schema.js",
    "chars": 10415,
    "preview": "\nexport const espdl = {};\n\nespdl.Version = {\n    _START_VERSION: 0, '0': '_START_VERSION',\n    IR_VERSION_2023_12_22: 1,"
  },
  {
    "path": "source/espdl.js",
    "chars": 14697,
    "preview": "import * as flatbuffers from './flatbuffers.js';\n\nconst espdl = {};\n\nespdl.ModelFactory = class {\n\n    async match(conte"
  },
  {
    "path": "source/espresso-metadata.json",
    "chars": 1294,
    "preview": "[\n  {\n    \"name\": \"convolution\",\n    \"category\": \"Layer\"\n  },\n  {\n    \"name\": \"inner_product\",\n    \"category\": \"Layer\"\n "
  },
  {
    "path": "source/espresso.js",
    "chars": 17573,
    "preview": "\nconst espresso = {};\n\nespresso.ModelFactory = class {\n\n    async match(context) {\n        const identifier = context.id"
  },
  {
    "path": "source/executorch-schema.js",
    "chars": 47700,
    "preview": "\nexport const executorch_flatbuffer = {};\n\nexport const fb_xnnpack = {};\n\nexport const vkgraph = {};\n\nexecutorch_flatbuf"
  },
  {
    "path": "source/executorch.js",
    "chars": 49835,
    "preview": "\n// Experimental\n\nconst executorch = {};\nconst coreml = {};\nconst vulkan = {};\nconst xnnpack = {};\nconst qnn = {};\nconst"
  },
  {
    "path": "source/flatbuffers.js",
    "chars": 16629,
    "preview": "\nconst flatbuffers = {};\n\nflatbuffers.BinaryReader = class {\n\n    static open(data, offset) {\n        offset = offset ||"
  },
  {
    "path": "source/flax.js",
    "chars": 6226,
    "preview": "\n// Experimental\n\nimport * as python from './python.js';\n\nconst flax = {};\n\nflax.ModelFactory = class {\n\n    async match"
  },
  {
    "path": "source/flexbuffers.js",
    "chars": 7479,
    "preview": "\nconst flexbuffers = {};\n\nflexbuffers.BinaryReader = class {\n\n    static open(buffer) {\n        const length = buffer.le"
  },
  {
    "path": "source/flux-metadata.json",
    "chars": 3,
    "preview": "[\n]"
  },
  {
    "path": "source/flux.js",
    "chars": 2178,
    "preview": "\n// Experimental\n\nconst flux = {};\n\nflux.ModelFactory = class {\n\n    async match(context) {\n        const identifier = c"
  },
  {
    "path": "source/gguf-metadata.json",
    "chars": 115017,
    "preview": "[\n  {\n    \"name\": \"llama\",\n    \"family\": \"decoder\",\n    \"graph\": {\n      \"input\": [\n        { \"name\": \"token_embd\", \"typ"
  },
  {
    "path": "source/gguf.js",
    "chars": 47617,
    "preview": "\nconst gguf = {};\n\ngguf.ModelFactory = class {\n\n    async match(context) {\n        const reader = gguf.Reader.open(conte"
  },
  {
    "path": "source/grapher.css",
    "chars": 7221,
    "preview": "\n.node path { stroke: #333; fill: none; stroke-width: 1px; }\n.node line { stroke: #333; fill: none; stroke-width: 1px; }"
  },
  {
    "path": "source/grapher.js",
    "chars": 36435,
    "preview": "\nconst grapher = {};\n\ngrapher.Graph = class {\n\n    constructor(compound) {\n        this._compound = compound;\n        th"
  },
  {
    "path": "source/hailo-metadata.json",
    "chars": 29854,
    "preview": "[\n  {\n    \"name\": \"input_layer\",\n    \"description\": \"Represents an input of the model\",\n    \"attributes\": [\n      {\n    "
  },
  {
    "path": "source/hailo.js",
    "chars": 13944,
    "preview": "// Experimental\n\nconst hailo = {};\n\nhailo.ModelFactory = class {\n\n    async match(context) {\n        const container = a"
  },
  {
    "path": "source/hdf5.js",
    "chars": 61463,
    "preview": "\n// Experimental HDF5 reader\n\nimport * as zip from './zip.js';\n\nconst hdf5 = {};\n\nhdf5.File = class {\n\n    static open(d"
  },
  {
    "path": "source/hickle.js",
    "chars": 5076,
    "preview": "\nconst hickle = {};\n\nhickle.ModelFactory = class {\n\n    async match(context) {\n        const group = await context.peek("
  },
  {
    "path": "source/imgdnn.js",
    "chars": 1035,
    "preview": "\nconst imgdnn = {};\n\nimgdnn.ModelFactory = class {\n\n    async match(context) {\n        const stream = context.stream;\n  "
  },
  {
    "path": "source/index.html",
    "chars": 51262,
    "preview": "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<meta name=\"description\" content=\"Visualizer for neural n"
  },
  {
    "path": "source/index.js",
    "chars": 4747,
    "preview": "window.exports = {};\n\nwindow.exports.require = function(id, callback) {\n    if (!/^[a-zA-Z0-9_-]+$/.test(id)) {\n        "
  },
  {
    "path": "source/json.js",
    "chars": 19647,
    "preview": "\nimport * as text from './text.js';\n\nconst json = {};\nconst bson = {};\n\njson.TextReader = class {\n\n    static open(data)"
  },
  {
    "path": "source/kann-metadata.json",
    "chars": 1531,
    "preview": "[\n    {\n        \"name\": \"Transpose\",\n        \"category\": \"Transform\"\n    },\n    {\n        \"name\": \"Substraction\",\n      "
  },
  {
    "path": "source/kann-schema.js",
    "chars": 3063,
    "preview": "\nexport const kann = {};\n\nkann.Model = class Model {\n\n    static identifier(reader) {\n        return reader.identifier ="
  },
  {
    "path": "source/kann.js",
    "chars": 7282,
    "preview": "\nconst kann = {};\n\nkann.ModelFactory = class {\n\n    async match(context) {\n        const reader = await context.peek('fl"
  },
  {
    "path": "source/keras-metadata.json",
    "chars": 249191,
    "preview": "[\n  {\n    \"name\": \"Activation\",\n    \"module\": \"keras.layers\",\n    \"category\": \"Activation\",\n    \"description\": \"Applies "
  },
  {
    "path": "source/keras-proto.js",
    "chars": 6112,
    "preview": "\nexport const third_party = {};\n\nthird_party.tensorflow = {};\n\nthird_party.tensorflow.python = {};\n\nthird_party.tensorfl"
  },
  {
    "path": "source/keras.js",
    "chars": 73136,
    "preview": "\nimport * as json from './json.js';\nimport * as python from './python.js';\n\nconst keras = {};\nconst tfjs = {};\n\nkeras.Mo"
  },
  {
    "path": "source/kmodel.js",
    "chars": 100942,
    "preview": "\nimport * as base from './base.js';\n\nconst kmodel = {};\n\nkmodel.ModelFactory = class {\n\n    async match(context) {\n     "
  },
  {
    "path": "source/lasagne-metadata.json",
    "chars": 244,
    "preview": "[\n  {\n    \"name\": \"lasagne.layers.conv.Conv2DLayer\",\n    \"category\": \"Layer\"\n  },\n  {\n    \"name\": \"lasagne.layers.pool.M"
  },
  {
    "path": "source/lasagne.js",
    "chars": 6529,
    "preview": "\n// Experimental\n\nconst lasagne = {};\n\nlasagne.ModelFactory = class {\n\n    async match(context) {\n        const obj = aw"
  },
  {
    "path": "source/lightgbm.js",
    "chars": 5155,
    "preview": "\nimport * as python from './python.js';\n\nconst lightgbm = {};\n\nlightgbm.ModelFactory = class {\n\n    async match(context)"
  },
  {
    "path": "source/mediapipe.js",
    "chars": 10376,
    "preview": "\nimport * as protobuf from './protobuf.js';\n\nconst mediapipe = {};\n\nmediapipe.ModelFactory = class {\n\n    async match(co"
  },
  {
    "path": "source/megengine-metadata.json",
    "chars": 91875,
    "preview": "[\n  {\n    \"name\": \"megengine.distributed.functional.all_gather\",\n    \"attributes\": [\n      { \"name\": \"inp\" },\n      { \"n"
  },
  {
    "path": "source/megengine-schema.js",
    "chars": 87357,
    "preview": "\nexport const mgb = {};\n\nmgb.serialization = mgb.serialization || {};\n\nmgb.serialization.fbs = mgb.serialization.fbs || "
  },
  {
    "path": "source/megengine.js",
    "chars": 30210,
    "preview": "\n// Experimental\n\nimport * as flatbuffers from './flatbuffers.js';\n\nconst megengine = {};\n\nmegengine.ModelFactory = clas"
  },
  {
    "path": "source/message.js",
    "chars": 5422,
    "preview": "\n// Experimental\n\nconst message = {};\n\nmessage.ModelFactory = class {\n\n    async match(context) {\n        const stream ="
  },
  {
    "path": "source/mlir-metadata.json",
    "chars": 8475700,
    "preview": "[\n  {\n    \"name\": \"acc.atomic.capture\",\n    \"summary\": \"performs an atomic capture\",\n    \"description\": \"This operation "
  },
  {
    "path": "source/mlir.js",
    "chars": 1087887,
    "preview": "\n// Experimental\n\nimport * as base from './base.js';\nimport * as text from './text.js';\n\nconst mlir = {};\nconst _ = {};\n"
  },
  {
    "path": "source/mlnet-metadata.json",
    "chars": 3423,
    "preview": "[\n  {\n    \"name\": \"CharToken\",\n    \"description\": \"Character-oriented tokenizer where text is considered a sequence of c"
  },
  {
    "path": "source/mlnet.js",
    "chars": 80589,
    "preview": "\n// Experimental\n\nimport * as base from './base.js';\n\nconst mlnet = {};\n\nmlnet.ModelFactory = class {\n\n    async match(c"
  },
  {
    "path": "source/mnn-metadata.json",
    "chars": 10297,
    "preview": "[\n  {\n    \"name\": \"AbsVal\",\n    \"operator\": 0\n  },\n  {\n    \"name\": \"ArgMax\",\n    \"operator\": 2\n  },\n  {\n    \"name\": \"AsS"
  },
  {
    "path": "source/mnn-schema.js",
    "chars": 120229,
    "preview": "\nexport const MNN = {};\n\nMNN.NetSource = {\n    CAFFE: 0, '0': 'CAFFE',\n    TENSORFLOW: 1, '1': 'TENSORFLOW',\n    TFLITE:"
  },
  {
    "path": "source/mnn.js",
    "chars": 16379,
    "preview": "\nconst mnn = {};\n\nmnn.ModelFactory = class {\n\n    async match(context) {\n        const reader = await context.peek('flat"
  },
  {
    "path": "source/mslite-metadata.json",
    "chars": 85645,
    "preview": "[\n  {\n    \"name\": \"Abs\",\n    \"inputs\": [\n      { \"name\": \"x\" }\n    ],\n    \"outputs\": [\n      { \"name\": \"y\" }\n    ]\n  },\n"
  },
  {
    "path": "source/mslite-schema.js",
    "chars": 166286,
    "preview": "\nexport const mindspore = {};\n\nmindspore.schema = mindspore.schema || {};\n\nmindspore.schema.ResizeMethod = {\n    UNKNOWN"
  },
  {
    "path": "source/mslite.js",
    "chars": 12282,
    "preview": "\nconst mslite = {};\n\nmslite.ModelFactory = class {\n\n    async match(context) {\n        const extension = context.identif"
  },
  {
    "path": "source/mxnet-metadata.json",
    "chars": 11629,
    "preview": "[\n  {\n    \"name\": \"_copy\",\n    \"inputs\": [\n      { \"name\": \"input\" }\n    ],\n    \"outputs\": [\n      { \"name\": \"output\" }\n"
  },
  {
    "path": "source/mxnet.js",
    "chars": 36684,
    "preview": "\nimport * as json from './json.js';\n\nconst mxnet = {};\n\nmxnet.ModelFactory = class {\n\n    async match(context) {\n       "
  },
  {
    "path": "source/ncnn-metadata.json",
    "chars": 33258,
    "preview": "[\n  {\n    \"name\": \"AbsVal\",\n    \"identifier\": 0\n  },\n  {\n    \"name\": \"ArgMax\",\n    \"identifier\": 1\n  },\n  {\n    \"name\": "
  },
  {
    "path": "source/ncnn.js",
    "chars": 49889,
    "preview": "\nimport * as base from './base.js';\n\nconst ncnn = {};\nconst pnnx = {};\n\n// https://github.com/Tencent/ncnn/wiki/param-an"
  },
  {
    "path": "source/nnabla-metadata.json",
    "chars": 296983,
    "preview": "[\n  {\n    \"name\": \"Affine\",\n    \"description\": \"Affine layer, also called as the fully connected layer. It calculates:\\n"
  },
  {
    "path": "source/nnabla-proto.js",
    "chars": 427254,
    "preview": "\nexport const nnabla = {};\n\nnnabla.Shape = class Shape {\n\n    constructor() {\n        this.dim = [];\n    }\n\n    static d"
  },
  {
    "path": "source/nnabla.js",
    "chars": 12318,
    "preview": "\nconst nnabla = {};\n\nnnabla.ModelFactory = class {\n\n    async match(context) {\n        const identifier = context.identi"
  },
  {
    "path": "source/nnef.js",
    "chars": 2368,
    "preview": "\nconst nnef = {};\n\nnnef.ModelFactory = class {\n\n    async match(context) {\n        const identifier = context.identifier"
  },
  {
    "path": "source/node.js",
    "chars": 3444,
    "preview": "\nimport * as fs from 'fs';\n\nconst node = {};\n\nnode.FileStream = class {\n\n    constructor(file, start, length, mtime) {\n "
  },
  {
    "path": "source/numpy.js",
    "chars": 9615,
    "preview": "\n// Experimental\n\nimport * as python from './python.js';\n\nconst numpy = {};\n\nnumpy.ModelFactory = class {\n\n    async mat"
  },
  {
    "path": "source/om-metadata.json",
    "chars": 53492,
    "preview": "[\n  {\n    \"name\": \"Acos\",\n    \"inputs\": [\n      { \"name\": \"x\" }\n    ],\n    \"outputs\": [\n      { \"name\": \"y\" }\n    ]\n  },"
  },
  {
    "path": "source/om-proto.js",
    "chars": 35979,
    "preview": "\nexport const ge = {};\n\nge.proto = {};\n\nge.proto.DataType = {\n    \"DT_UNDEFINED\": 0,\n    \"DT_FLOAT\": 1,\n    \"DT_FLOAT16\""
  },
  {
    "path": "source/om.js",
    "chars": 33096,
    "preview": "\n// Experimental\n\nimport * as base from './base.js';\nimport * as protobuf from './protobuf.js';\n\nconst om = {};\nconst sv"
  },
  {
    "path": "source/onednn-metadata.json",
    "chars": 6761,
    "preview": "[\n  {\n    \"name\": \"End\"\n  },\n  {\n    \"name\": \"Wildcard\"\n  },\n  {\n    \"name\": \"StaticReshape\",\n    \"category\": \"Shape\"\n  "
  },
  {
    "path": "source/onnx-proto.js",
    "chars": 92651,
    "preview": "\nexport const onnx = {};\n\nonnx.Version = {\n    \"_START_VERSION\": 0,\n    \"IR_VERSION_2017_10_10\": 1,\n    \"IR_VERSION_2017"
  },
  {
    "path": "source/onnx-schema.js",
    "chars": 15377,
    "preview": "\nexport const onnxruntime = {};\n\nonnxruntime.fbs = onnxruntime.fbs || {};\n\nonnxruntime.fbs.AttributeType = {\n    UNDEFIN"
  },
  {
    "path": "source/onnx.py",
    "chars": 8342,
    "preview": "\"\"\" ONNX backend \"\"\"\n\nimport collections\nimport enum\nimport json\nimport os\n\n\nclass ModelFactory:\n    \"\"\" ONNX backend mo"
  },
  {
    "path": "source/openvino-metadata.json",
    "chars": 87046,
    "preview": "[\n  {\n    \"name\": \"Activation\",\n    \"category\": \"Activation\",\n    \"description\": \"*Activation* layer represents an activ"
  },
  {
    "path": "source/openvino.js",
    "chars": 40553,
    "preview": "\nconst openvino = {};\n\nopenvino.ModelFactory = class {\n\n    async match(context) {\n        const identifier = context.id"
  },
  {
    "path": "source/paddle.js",
    "chars": 58451,
    "preview": "\nimport * as base from './base.js';\nimport * as flatbuffers from './flatbuffers.js';\nimport * as protobuf from './protob"
  },
  {
    "path": "source/pickle.js",
    "chars": 18906,
    "preview": "\n// Experimental\n\nconst pickle = {};\n\npickle.ModelFactory = class {\n\n    async match(context) {\n        const stream = c"
  },
  {
    "path": "source/python.js",
    "chars": 1157536,
    "preview": "\n// Experimental Python Execution\n\nconst python = {};\n\npython.Execution = class {\n\n    constructor(sources) {\n        /*"
  }
]

// ... and 119 more files (download for full content)

About this extraction

This page contains the full source code of the lutzroeder/netron GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 252 files (26.5 MB), approximately 4.2M tokens, and a symbol index with 6485 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.

Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.

Extract another repo