zkjson 0.1.20 → 0.1.22
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/encoder.js +74 -74
- package/package.json +1 -1
- package/parse.js +161 -162
- package/uint.js +255 -203
package/parse.js
CHANGED
|
@@ -1,152 +1,121 @@
|
|
|
1
|
-
const {
|
|
1
|
+
const {
|
|
2
|
+
toArray,
|
|
3
|
+
concat,
|
|
4
|
+
sum,
|
|
5
|
+
get,
|
|
6
|
+
popArray,
|
|
7
|
+
pushArray,
|
|
8
|
+
length,
|
|
9
|
+
next,
|
|
10
|
+
arr: _arr,
|
|
11
|
+
push,
|
|
12
|
+
pop,
|
|
13
|
+
last,
|
|
14
|
+
bn,
|
|
15
|
+
} = require("./uint")
|
|
2
16
|
const _null_ = [110, 117, 108, 108]
|
|
3
17
|
const _true_ = [116, 114, 117, 101]
|
|
4
18
|
const _false_ = [102, 97, 108, 115, 101]
|
|
5
19
|
|
|
6
|
-
|
|
7
|
-
if (a.length != b.length) return 0
|
|
8
|
-
for (let i = 0; i < b.length; i++) {
|
|
9
|
-
if (a[i] != b[i]) return 0
|
|
10
|
-
}
|
|
11
|
-
return 1
|
|
12
|
-
}
|
|
13
|
-
|
|
14
|
-
const eql2 = (a, b, blen, size = 100) => {
|
|
20
|
+
function eql(a, b, blen, size) {
|
|
15
21
|
var alen = length(a, size)
|
|
16
22
|
if (alen != blen) return 0
|
|
17
23
|
var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
|
|
18
|
-
for (
|
|
24
|
+
for (var i = 0; i < blen; i++) {
|
|
19
25
|
c = next(a, c)
|
|
20
26
|
if (c[0] != b[i]) return 0
|
|
21
27
|
}
|
|
22
28
|
return 1
|
|
23
29
|
}
|
|
24
30
|
|
|
25
|
-
const constVal = (_v, type) => {
|
|
26
|
-
let val = []
|
|
27
|
-
val.push(type)
|
|
28
|
-
if (type == 1) {
|
|
29
|
-
if (eql(_v, _true_) == 1) {
|
|
30
|
-
val.push(1)
|
|
31
|
-
} else {
|
|
32
|
-
val.push(0)
|
|
33
|
-
}
|
|
34
|
-
} else if (type == 3) {
|
|
35
|
-
val.push(_v.length)
|
|
36
|
-
for (let v of _v) {
|
|
37
|
-
val.push(v)
|
|
38
|
-
}
|
|
39
|
-
} else if (type == 2) {
|
|
40
|
-
if (_v[0] == 45) {
|
|
41
|
-
val.push(0)
|
|
42
|
-
} else {
|
|
43
|
-
val.push(1)
|
|
44
|
-
}
|
|
45
|
-
let after = 0
|
|
46
|
-
let right = 0
|
|
47
|
-
let digits = 0
|
|
48
|
-
for (let v of _v) {
|
|
49
|
-
if (v == 46) {
|
|
50
|
-
after = 1
|
|
51
|
-
} else if (v != 45) {
|
|
52
|
-
if (after == 1) right += 1
|
|
53
|
-
digits = digits * 10 + (v - 48)
|
|
54
|
-
}
|
|
55
|
-
}
|
|
56
|
-
val.push(right)
|
|
57
|
-
val.push(digits)
|
|
58
|
-
}
|
|
59
|
-
return val
|
|
60
|
-
}
|
|
61
|
-
|
|
62
|
-
const constVal2 = (_v, type, size) => {
|
|
31
|
+
const constVal = (_v, type, size, digit = 9) => {
|
|
63
32
|
var val = _arr(size)
|
|
64
|
-
push(val, size,
|
|
33
|
+
val = push(val, size, digit, type)
|
|
65
34
|
if (type == 1) {
|
|
66
|
-
if (
|
|
67
|
-
push(val, size,
|
|
35
|
+
if (eql(_v, _true_, 4, size) == 1) {
|
|
36
|
+
val = push(val, size, digit, 1)
|
|
68
37
|
} else {
|
|
69
|
-
push(val, size,
|
|
38
|
+
val = push(val, size, digit, 0)
|
|
70
39
|
}
|
|
71
40
|
} else if (type == 3) {
|
|
72
|
-
push(length(_v, size))
|
|
73
|
-
var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
|
|
41
|
+
val = push(val, size, digit, length(_v, size))
|
|
42
|
+
var c = bn([0, size, 0, 0, 0, 0, 0, 0, 0])
|
|
74
43
|
while (c[5] == 0) {
|
|
75
44
|
c = next(_v, c)
|
|
76
|
-
push(val, size,
|
|
45
|
+
val = push(val, size, digit, c[0])
|
|
77
46
|
}
|
|
78
47
|
} else if (type == 2) {
|
|
79
|
-
if (_v
|
|
80
|
-
push(val, size,
|
|
48
|
+
if (get(_v, size, 0) == 45) {
|
|
49
|
+
val = push(val, size, digit, 0)
|
|
81
50
|
} else {
|
|
82
|
-
push(val, size,
|
|
51
|
+
val = push(val, size, digit, 1)
|
|
83
52
|
}
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
|
|
53
|
+
var after = 0n
|
|
54
|
+
var right = 0n
|
|
55
|
+
var digits = 0n
|
|
56
|
+
var c = bn([0, size, 0, 0, 0, 0, 0, 0, 0])
|
|
88
57
|
while (c[5] == 0) {
|
|
89
58
|
c = next(_v, c)
|
|
90
59
|
if (c[0] == 46) {
|
|
91
60
|
after = 1
|
|
92
61
|
} else if (c[0] != 45) {
|
|
93
|
-
if (after == 1) right +=
|
|
94
|
-
digits = digits *
|
|
62
|
+
if (after == 1) right += 1n
|
|
63
|
+
digits = digits * 10n + (c[0] - 48n)
|
|
95
64
|
}
|
|
96
65
|
}
|
|
97
|
-
push(val, size,
|
|
98
|
-
push(val, size,
|
|
66
|
+
val = push(val, size, digit, right)
|
|
67
|
+
val = push(val, size, digit, digits)
|
|
99
68
|
}
|
|
100
69
|
return val
|
|
101
70
|
}
|
|
102
71
|
|
|
103
|
-
const constPath = p => {
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
72
|
+
const constPath = (p, size, digit = 9) => {
|
|
73
|
+
var pth2 = _arr(size)
|
|
74
|
+
var len = get(p, size, 0)
|
|
75
|
+
pth2 = push(pth2, size, digit, len)
|
|
76
|
+
for (var i = 0n; i < len; i++) {
|
|
77
|
+
var len2 = get(p, size, i + 1n)
|
|
78
|
+
var _sum = sum(p, size, digit, 1, 1n + i)
|
|
79
|
+
var first = get(p, size, 1n + len + _sum)
|
|
80
|
+
if (first == 0) {
|
|
81
|
+
pth2 = push(pth2, size, digit, 0)
|
|
109
82
|
} else {
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
83
|
+
pth2 = push(pth2, size, digit, len2)
|
|
84
|
+
}
|
|
85
|
+
for (var i2 = 0n; i2 < len2; i2++) {
|
|
86
|
+
var v = get(p, size, 1n + len + _sum + i2)
|
|
87
|
+
pth2 = push(pth2, size, digit, v)
|
|
113
88
|
}
|
|
114
89
|
}
|
|
115
|
-
return
|
|
90
|
+
return pth2
|
|
116
91
|
}
|
|
117
92
|
|
|
118
|
-
const
|
|
119
|
-
|
|
120
|
-
var
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
for (let v2 of _v) pth.push(v2)
|
|
125
|
-
} else {
|
|
126
|
-
pth.push(0)
|
|
127
|
-
pth.push(0)
|
|
128
|
-
pth.push(_v)
|
|
129
|
-
}
|
|
93
|
+
const isNumber = (val, size, digit) => {
|
|
94
|
+
var len = length(val, size)
|
|
95
|
+
var c = [0, size, 0, 0, 0, 0, 0, 0, 0]
|
|
96
|
+
while (c[5] == 0) {
|
|
97
|
+
c = next(val, c)
|
|
98
|
+
if (c[0] == 47 || c[0] < 45 || c[0] > 57) return 0
|
|
130
99
|
}
|
|
131
|
-
|
|
100
|
+
|
|
101
|
+
return 1
|
|
132
102
|
}
|
|
133
103
|
|
|
134
|
-
const parse = (str, size = 100) => {
|
|
135
|
-
|
|
136
|
-
var
|
|
104
|
+
const parse = (str, size = 100, digit = 9) => {
|
|
105
|
+
str = bn(str)
|
|
106
|
+
var val = _arr(size)
|
|
137
107
|
var inVal = 0
|
|
138
108
|
var isNum = 0
|
|
139
109
|
var esc = 0
|
|
140
110
|
var nextKey = 0
|
|
141
111
|
var arr = 0
|
|
142
112
|
var obj = 0
|
|
143
|
-
var path =
|
|
144
|
-
var path2 = _arr(size)
|
|
113
|
+
var path = _arr(size)
|
|
145
114
|
var ao = _arr(5)
|
|
146
115
|
var ind = _arr(5)
|
|
147
116
|
var err = 0
|
|
148
|
-
var json =
|
|
149
|
-
|
|
117
|
+
var json = _arr(size)
|
|
118
|
+
var c = bn([0, size, 0, 0, 0, 0, 0, 0, 0])
|
|
150
119
|
while (c[5] == 0) {
|
|
151
120
|
c = next(str, c)
|
|
152
121
|
var s = c[0]
|
|
@@ -155,84 +124,101 @@ const parse = (str, size = 100) => {
|
|
|
155
124
|
esc = 1
|
|
156
125
|
} else if (s == 34) {
|
|
157
126
|
if (esc == 1) {
|
|
158
|
-
val
|
|
159
|
-
push(val2, size, 9, s)
|
|
127
|
+
val = push(val, size, digit, s)
|
|
160
128
|
} else {
|
|
161
129
|
inVal = 0
|
|
162
130
|
if (nextKey == 1 && last(ao, 5) == 1) {
|
|
163
|
-
path
|
|
131
|
+
path = pushArray(path, size, digit, val, size)
|
|
164
132
|
} else {
|
|
165
133
|
if (last(ao, 5) == 2) {
|
|
166
134
|
var _ind = last(ind, 5)
|
|
167
|
-
|
|
135
|
+
var __ind = _arr(size)
|
|
136
|
+
__ind = push(__ind, size, digit, 0)
|
|
137
|
+
__ind = push(__ind, size, digit, _ind)
|
|
138
|
+
path = pushArray(path, size, digit, __ind, size)
|
|
168
139
|
ind = pop(ind, 5)
|
|
169
|
-
push(ind, 5,
|
|
140
|
+
ind = push(ind, 5, digit, _ind + 1)
|
|
170
141
|
}
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
142
|
+
json = concat(
|
|
143
|
+
json,
|
|
144
|
+
concat(
|
|
145
|
+
constPath(path, size, digit),
|
|
146
|
+
constVal(val, 3, size, digit),
|
|
147
|
+
size,
|
|
148
|
+
digit,
|
|
149
|
+
),
|
|
150
|
+
size,
|
|
151
|
+
digit,
|
|
152
|
+
)
|
|
153
|
+
path = popArray(path, size, digit)
|
|
175
154
|
}
|
|
176
155
|
|
|
177
|
-
val =
|
|
178
|
-
val2 = _arr(size)
|
|
156
|
+
val = _arr(size)
|
|
179
157
|
nextKey = 0
|
|
180
158
|
}
|
|
181
159
|
esc = 0
|
|
182
160
|
} else {
|
|
183
|
-
val
|
|
184
|
-
push(val2, size, 9, s)
|
|
161
|
+
val = push(val, size, digit, s)
|
|
185
162
|
esc = 0
|
|
186
163
|
}
|
|
187
164
|
} else if (isNum == 1) {
|
|
188
165
|
if (s == 44 || s == 32 || s == 125 || s == 93) {
|
|
189
166
|
if (last(ao, 5) == 2) {
|
|
190
167
|
var _ind = last(ind, 5)
|
|
191
|
-
|
|
168
|
+
var __ind = _arr(size)
|
|
169
|
+
__ind = push(__ind, size, digit, 0)
|
|
170
|
+
__ind = push(__ind, size, digit, _ind)
|
|
171
|
+
path = pushArray(path, size, digit, __ind, size)
|
|
192
172
|
ind = pop(ind, 5)
|
|
193
|
-
push(ind, 5,
|
|
173
|
+
ind = push(ind, 5, digit, _ind + 1n)
|
|
194
174
|
}
|
|
195
175
|
if (
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
176
|
+
eql(val, _true_, 4, size) == 0 &&
|
|
177
|
+
eql(val, _false_, 5, size) == 0 &&
|
|
178
|
+
eql(val, _null_, 4, size) == 0 &&
|
|
179
|
+
isNumber(val, size, digit) == 0
|
|
200
180
|
) {
|
|
201
181
|
err = 1
|
|
202
182
|
}
|
|
203
|
-
// console.log("val: ", `< ${path.join(".")} >`, val)
|
|
204
183
|
var type = 2
|
|
205
|
-
if (
|
|
184
|
+
if (eql(val, _null_, 4, size) == 1) {
|
|
206
185
|
type = 0
|
|
207
186
|
} else if (
|
|
208
|
-
|
|
209
|
-
|
|
187
|
+
eql(val, _true_, 4, size) == 1 ||
|
|
188
|
+
eql(val, _false_, 5, size) == 1
|
|
210
189
|
) {
|
|
211
190
|
type = 1
|
|
212
191
|
}
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
192
|
+
json = concat(
|
|
193
|
+
json,
|
|
194
|
+
concat(
|
|
195
|
+
constPath(path, size, digit),
|
|
196
|
+
constVal(val, type, size, digit),
|
|
197
|
+
size,
|
|
198
|
+
digit,
|
|
199
|
+
),
|
|
200
|
+
size,
|
|
201
|
+
digit,
|
|
202
|
+
)
|
|
203
|
+
path = popArray(path, size, digit)
|
|
216
204
|
if (s == 93) {
|
|
217
205
|
if (last(ao, 5) != 2) err = 1
|
|
218
|
-
ao
|
|
219
|
-
path
|
|
206
|
+
ao = pop(ao, 5)
|
|
207
|
+
path = popArray(path, size, digit)
|
|
220
208
|
arr--
|
|
221
|
-
pop(ind, 5)
|
|
209
|
+
ind = pop(ind, 5)
|
|
222
210
|
}
|
|
223
211
|
if (s == 125) {
|
|
224
212
|
if (last(ao, 5) != 1) err = 1
|
|
225
|
-
pop(ao, 5)
|
|
226
|
-
path
|
|
213
|
+
ao = pop(ao, 5)
|
|
214
|
+
path = popArray(path, size, digit)
|
|
227
215
|
obj--
|
|
228
216
|
}
|
|
229
217
|
isNum = 0
|
|
230
|
-
val =
|
|
231
|
-
val2 = _arr(size)
|
|
218
|
+
val = _arr(size)
|
|
232
219
|
if (s == 44) nextKey = 1
|
|
233
220
|
} else {
|
|
234
|
-
val
|
|
235
|
-
push(val2, size, 9, s)
|
|
221
|
+
val = push(val, size, digit, s)
|
|
236
222
|
}
|
|
237
223
|
} else if (s == 34) {
|
|
238
224
|
inVal = 1
|
|
@@ -246,69 +232,82 @@ const parse = (str, size = 100) => {
|
|
|
246
232
|
s != 125
|
|
247
233
|
) {
|
|
248
234
|
isNum = 1
|
|
249
|
-
val
|
|
250
|
-
push(val2, size, 9, s)
|
|
235
|
+
val = push(val, size, digit, s)
|
|
251
236
|
} else {
|
|
252
237
|
if (s != 32) {
|
|
253
238
|
if (s == 123 || s == 44) nextKey = 1
|
|
254
239
|
if (s == 123) {
|
|
255
240
|
if (last(ao, 5) == 2) {
|
|
256
241
|
var _ind = last(ind, 5)
|
|
257
|
-
|
|
242
|
+
var __ind = _arr(size)
|
|
243
|
+
__ind = push(__ind, size, digit, 0)
|
|
244
|
+
__ind = push(__ind, size, digit, _ind)
|
|
245
|
+
path = pushArray(path, size, digit, __ind, size)
|
|
258
246
|
ind = pop(ind, 5)
|
|
259
|
-
push(ind, 5,
|
|
247
|
+
ind = push(ind, 5, digit, _ind + 1)
|
|
260
248
|
}
|
|
261
|
-
push(ao, 5,
|
|
249
|
+
ao = push(ao, 5, digit, 1)
|
|
262
250
|
obj++
|
|
263
251
|
}
|
|
264
252
|
if (s == 125) {
|
|
265
253
|
if (last(ao, 5) != 1) err = 1
|
|
266
|
-
pop(ao, 5)
|
|
267
|
-
path
|
|
254
|
+
ao = pop(ao, 5)
|
|
255
|
+
path = popArray(path, size, digit)
|
|
268
256
|
obj--
|
|
269
257
|
}
|
|
270
258
|
if (s == 91) {
|
|
271
259
|
if (last(ao, 5) == 2) {
|
|
272
260
|
var _ind = last(ind, 5)
|
|
273
|
-
|
|
261
|
+
var __ind = _arr(size)
|
|
262
|
+
__ind = push(__ind, size, digit, 0)
|
|
263
|
+
__ind = push(__ind, size, digit, _ind)
|
|
264
|
+
path = pushArray(path, size, digit, __ind, size)
|
|
274
265
|
ind = pop(ind, 5)
|
|
275
|
-
push(ind, 5,
|
|
266
|
+
ind = push(ind, 5, digit, _ind + 1)
|
|
276
267
|
}
|
|
277
|
-
push(ind, 5,
|
|
278
|
-
push(ao, 5,
|
|
268
|
+
ind = push(ind, 5, digit, 0)
|
|
269
|
+
ao = push(ao, 5, digit, 2)
|
|
279
270
|
arr++
|
|
280
271
|
}
|
|
281
272
|
if (s == 93) {
|
|
282
273
|
if (last(ao, 5) != 2) err = 1
|
|
283
|
-
pop(ao, 5)
|
|
284
|
-
pop(ind, 5)
|
|
285
|
-
path
|
|
274
|
+
ao = pop(ao, 5)
|
|
275
|
+
ind = pop(ind, 5)
|
|
276
|
+
path = popArray(path, size, digit)
|
|
286
277
|
arr--
|
|
287
278
|
}
|
|
288
279
|
}
|
|
289
280
|
}
|
|
290
281
|
}
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
282
|
+
if (length(val, size) != 0) {
|
|
283
|
+
var type = 4
|
|
284
|
+
if (eql(val, _null_, 4, size) == 1) {
|
|
285
|
+
type = 0
|
|
286
|
+
isNum = 0
|
|
287
|
+
} else if (eql(val, _true_, 4, size) == 1 || eql(val, _false_, 5, size)) {
|
|
288
|
+
type = 1
|
|
289
|
+
isNum = 0
|
|
290
|
+
} else if (isNumber(val, size, digit) == 1) {
|
|
291
|
+
type = 2
|
|
292
|
+
isNum = 0
|
|
293
|
+
}
|
|
294
|
+
json = concat(
|
|
295
|
+
json,
|
|
296
|
+
concat(
|
|
297
|
+
constPath(path, size, digit),
|
|
298
|
+
constVal(val, type, size, digit),
|
|
299
|
+
size,
|
|
300
|
+
digit,
|
|
301
|
+
),
|
|
302
|
+
size,
|
|
303
|
+
digit,
|
|
304
|
+
)
|
|
298
305
|
}
|
|
299
306
|
if (ao.length > 0) err = 1
|
|
300
307
|
if (ind.length > 0) err = 1
|
|
301
308
|
if (inVal) err = 1
|
|
302
309
|
if (isNum) err = 1
|
|
303
|
-
|
|
304
|
-
for (var v of json) {
|
|
305
|
-
for (var v2 of v) {
|
|
306
|
-
for (var v3 of v2) {
|
|
307
|
-
j = push(j, size, 9, v3)
|
|
308
|
-
}
|
|
309
|
-
}
|
|
310
|
-
}
|
|
311
|
-
return j
|
|
310
|
+
return json
|
|
312
311
|
}
|
|
313
312
|
|
|
314
313
|
module.exports = { parse }
|