changed #range from end index to size - #5

…L files (#5)

* web/k-web-theme: 9314777 - For RV Website generating pages and blog (#3)

* web/k-web-theme: c995d8e - fix: Fixed few markdown preview styles (#4)

* web/k-web-theme: 2139b52 - Updated few functions for building the HTML files (#5)

* web/k-web-theme: 9c5dccf - fix: Fixed the code block styling in dark mode (#6)

* web/k-web-theme: 090f448 - Moved public_content dir from web-common to k-web-theme static_content (#7)

Previously we were parsing the json tests in python, then converting
them to KORE and passing them to the backend which then used the kore
parser to parse them. This is fairly inefficient, because we end up
parsing things twice.

The solution is pretty straightforward. We simply send the entire json
file to the backend as a single `String`, then invoke the llvm backend's
json parser, which is extremely fast, on the resulting term. It's a
fairly basic change, but it significantly improves performance.

Time on the base branch:
```
real    6m21.214s
user    75m41.967s
sys     3m35.565s
```
Time on the branch containing the change:
```
real    5m23.010s
user    46m6.622s
sys     2m47.065s
```

Previously we were parsing the json tests in python, then converting
them to KORE and passing them to the backend which then used the kore
parser to parse them. This is fairly inefficient, because we end up
parsing things twice.

The solution is pretty straightforward. We simply send the entire json
file to the backend as a single `String`, then invoke the llvm backend's
json parser, which is extremely fast, on the resulting term. It's a
fairly basic change, but it significantly improves performance.

Time on the base branch:
```
real    6m21.214s
user    75m41.967s
sys     3m35.565s
```
Time on the branch containing the change:
```
real    5m23.010s
user    46m6.622s
sys     2m47.065s
```

Previously we were parsing the json tests in python, then converting
them to KORE and passing them to the backend which then used the kore
parser to parse them. This is fairly inefficient, because we end up
parsing things twice.

The solution is pretty straightforward. We simply send the entire json
file to the backend as a single `String`, then invoke the llvm backend's
json parser, which is extremely fast, on the resulting term. It's a
fairly basic change, but it significantly improves performance.

Time on the base branch:
```
real    6m21.214s
user    75m41.967s
sys     3m35.565s
```
Time on the branch containing the change:
```
real    5m23.010s
user    46m6.622s
sys     2m47.065s
```

Previously we were parsing the json tests in python, then converting
them to KORE and passing them to the backend which then used the kore
parser to parse them. This is fairly inefficient, because we end up
parsing things twice.

The solution is pretty straightforward. We simply send the entire json
file to the backend as a single `String`, then invoke the llvm backend's
json parser, which is extremely fast, on the resulting term. It's a
fairly basic change, but it significantly improves performance.

Time on the base branch:
```
real    6m21.214s
user    75m41.967s
sys     3m35.565s
```
Time on the branch containing the change:
```
real    5m23.010s
user    46m6.622s
sys     2m47.065s
```

Previously we were parsing the json tests in python, then converting
them to KORE and passing them to the backend which then used the kore
parser to parse them. This is fairly inefficient, because we end up
parsing things twice.

The solution is pretty straightforward. We simply send the entire json
file to the backend as a single `String`, then invoke the llvm backend's
json parser, which is extremely fast, on the resulting term. It's a
fairly basic change, but it significantly improves performance.

Time on the base branch:
```
real    6m21.214s
user    75m41.967s
sys     3m35.565s
```
Time on the branch containing the change:
```
real    5m23.010s
user    46m6.622s
sys     2m47.065s
```

Previously we were parsing the json tests in python, then converting
them to KORE and passing them to the backend which then used the kore
parser to parse them. This is fairly inefficient, because we end up
parsing things twice.

The solution is pretty straightforward. We simply send the entire json
file to the backend as a single `String`, then invoke the llvm backend's
json parser, which is extremely fast, on the resulting term. It's a
fairly basic change, but it significantly improves performance.

Time on the base branch:
```
real    6m21.214s
user    75m41.967s
sys     3m35.565s
```
Time on the branch containing the change:
```
real    5m23.010s
user    46m6.622s
sys     2m47.065s
```