2018-12-23 16:21:37 +00:00
|
|
|
{
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"version": 1,
|
|
|
|
"parameters": {
|
|
|
|
"decodelevel": "generalized"
|
2019-01-02 02:27:18 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"pages": [
|
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"38 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "6 0 R",
|
|
|
|
"outlines": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"6 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"object": "103 0 R",
|
|
|
|
"title": "Merschqaberschq (A) 1.2.2 -> 0: /XYZ null null null"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"pageposfrom1": 1
|
2020-01-26 19:38:56 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"42 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "7 0 R",
|
|
|
|
"outlines": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"7 0 R",
|
|
|
|
"/FitR",
|
|
|
|
66,
|
|
|
|
714,
|
|
|
|
180,
|
|
|
|
770
|
|
|
|
],
|
|
|
|
"object": "102 0 R",
|
|
|
|
"title": "Gabeebeebee (name) 1.2.1 -> 1: /FitR 66 714 180 770"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"pageposfrom1": 2
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"44 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "8 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 3
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"46 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "9 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 4
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"48 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "10 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 5
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"50 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "11 0 R",
|
|
|
|
"outlines": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"11 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"object": "4 0 R",
|
|
|
|
"title": "Potato 1 -> 5: /XYZ null null null"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"pageposfrom1": 6
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"52 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "12 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 7
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"54 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "13 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 8
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"56 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "14 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 9
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"58 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "15 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 10
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"60 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "16 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 11
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"62 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "17 0 R",
|
|
|
|
"outlines": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"17 0 R",
|
|
|
|
"/Fit"
|
|
|
|
],
|
|
|
|
"object": "36 0 R",
|
|
|
|
"title": "Mern 1.1 -> 11: /Fit"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"pageposfrom1": 12
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"64 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "18 0 R",
|
|
|
|
"outlines": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"18 0 R",
|
|
|
|
"/FitV",
|
|
|
|
100
|
|
|
|
],
|
|
|
|
"object": "100 0 R",
|
|
|
|
"title": "Biherbadem 1.1.1 -> 12: /FitV 100"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"18 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"object": "101 0 R",
|
|
|
|
"title": "Gawehwehweh 1.1.2 -> 12: /XYZ null null null"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"pageposfrom1": 13
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"66 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "19 0 R",
|
|
|
|
"outlines": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"19 0 R",
|
|
|
|
"/FitH",
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"object": "37 0 R",
|
|
|
|
"title": "Squash ÷πʬ÷ 1.2 -> 13: /FitH 792"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"pageposfrom1": 14
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"68 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "20 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 15
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"70 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "21 0 R",
|
|
|
|
"outlines": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"21 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
66,
|
|
|
|
756,
|
|
|
|
3
|
|
|
|
],
|
|
|
|
"object": "5 0 R",
|
|
|
|
"title": "Salad 2 -> 15: /XYZ 66 756 3"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"pageposfrom1": 16
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"72 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "22 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 17
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"74 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "23 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 18
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"76 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "24 0 R",
|
|
|
|
"outlines": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"24 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"object": "104 0 R",
|
|
|
|
"title": "Glarpenspliel (A, name) 1.1.1.1 -> 18: /XYZ null null null"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"pageposfrom1": 19
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"78 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "25 0 R",
|
|
|
|
"outlines": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"25 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"object": "105 0 R",
|
|
|
|
"title": "Hagoogamagoogle 1.1.1.2 -> 19: /XYZ null null null"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"pageposfrom1": 20
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"80 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "26 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 21
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"82 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "27 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 22
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"84 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "28 0 R",
|
|
|
|
"outlines": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"28 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"object": "106 0 R",
|
|
|
|
"title": "Jawarnianbvarwash 1.1.2.1 -> 22: /XYZ null null null"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"pageposfrom1": 23
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"86 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "29 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 24
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"88 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "30 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 25
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"90 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "31 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 26
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"92 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "32 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 27
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"94 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "33 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 28
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"96 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "34 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 29
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"contents": [
|
|
|
|
"98 0 R"
|
|
|
|
],
|
|
|
|
"images": [],
|
|
|
|
"label": null,
|
|
|
|
"object": "35 0 R",
|
|
|
|
"outlines": [],
|
|
|
|
"pageposfrom1": 30
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"pagelabels": [],
|
|
|
|
"acroform": {
|
|
|
|
"fields": [],
|
|
|
|
"hasacroform": false,
|
|
|
|
"needappearances": false
|
|
|
|
},
|
|
|
|
"attachments": {},
|
|
|
|
"encrypt": {
|
|
|
|
"capabilities": {
|
|
|
|
"accessibility": true,
|
|
|
|
"extract": true,
|
|
|
|
"moddifyannotations": true,
|
|
|
|
"modify": true,
|
|
|
|
"modifyassembly": true,
|
|
|
|
"modifyforms": true,
|
|
|
|
"modifyother": true,
|
|
|
|
"printhigh": true,
|
|
|
|
"printlow": true
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"encrypted": false,
|
|
|
|
"ownerpasswordmatched": false,
|
|
|
|
"parameters": {
|
|
|
|
"P": 0,
|
|
|
|
"R": 0,
|
|
|
|
"V": 0,
|
|
|
|
"bits": 0,
|
|
|
|
"filemethod": "none",
|
|
|
|
"key": null,
|
|
|
|
"method": "none",
|
|
|
|
"streammethod": "none",
|
|
|
|
"stringmethod": "none"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"userpasswordmatched": false
|
|
|
|
},
|
|
|
|
"outlines": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"11 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"destpageposfrom1": 6,
|
|
|
|
"kids": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"17 0 R",
|
|
|
|
"/Fit"
|
|
|
|
],
|
|
|
|
"destpageposfrom1": 12,
|
|
|
|
"kids": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"18 0 R",
|
|
|
|
"/FitV",
|
|
|
|
100
|
|
|
|
],
|
|
|
|
"destpageposfrom1": 13,
|
|
|
|
"kids": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"24 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"destpageposfrom1": 19,
|
|
|
|
"kids": [],
|
|
|
|
"object": "104 0 R",
|
|
|
|
"open": true,
|
|
|
|
"title": "Glarpenspliel (A, name) 1.1.1.1 -> 18: /XYZ null null null"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"25 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"destpageposfrom1": 20,
|
|
|
|
"kids": [],
|
|
|
|
"object": "105 0 R",
|
|
|
|
"open": true,
|
|
|
|
"title": "Hagoogamagoogle 1.1.1.2 -> 19: /XYZ null null null"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"object": "100 0 R",
|
|
|
|
"open": false,
|
|
|
|
"title": "Biherbadem 1.1.1 -> 12: /FitV 100"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"18 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"destpageposfrom1": 13,
|
|
|
|
"kids": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"28 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"destpageposfrom1": 23,
|
|
|
|
"kids": [],
|
|
|
|
"object": "106 0 R",
|
|
|
|
"open": true,
|
|
|
|
"title": "Jawarnianbvarwash 1.1.2.1 -> 22: /XYZ null null null"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"object": "101 0 R",
|
|
|
|
"open": true,
|
|
|
|
"title": "Gawehwehweh 1.1.2 -> 12: /XYZ null null null"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"object": "36 0 R",
|
|
|
|
"open": false,
|
|
|
|
"title": "Mern 1.1 -> 11: /Fit"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"19 0 R",
|
|
|
|
"/FitH",
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"destpageposfrom1": 14,
|
|
|
|
"kids": [
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"7 0 R",
|
|
|
|
"/FitR",
|
|
|
|
66,
|
|
|
|
714,
|
|
|
|
180,
|
|
|
|
770
|
|
|
|
],
|
|
|
|
"destpageposfrom1": 2,
|
|
|
|
"kids": [],
|
|
|
|
"object": "102 0 R",
|
|
|
|
"open": true,
|
|
|
|
"title": "Gabeebeebee (name) 1.2.1 -> 1: /FitR 66 714 180 770"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"6 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"destpageposfrom1": 1,
|
|
|
|
"kids": [],
|
|
|
|
"object": "103 0 R",
|
|
|
|
"open": true,
|
|
|
|
"title": "Merschqaberschq (A) 1.2.2 -> 0: /XYZ null null null"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"object": "37 0 R",
|
|
|
|
"open": true,
|
|
|
|
"title": "Squash ÷πʬ÷ 1.2 -> 13: /FitH 792"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"object": "4 0 R",
|
|
|
|
"open": true,
|
|
|
|
"title": "Potato 1 -> 5: /XYZ null null null"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
{
|
|
|
|
"dest": [
|
|
|
|
"21 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
66,
|
|
|
|
756,
|
|
|
|
3
|
|
|
|
],
|
|
|
|
"destpageposfrom1": 16,
|
|
|
|
"kids": [],
|
|
|
|
"object": "5 0 R",
|
|
|
|
"open": true,
|
|
|
|
"title": "Salad 2 -> 15: /XYZ 66 756 3"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"objects": {
|
|
|
|
"1 0 R": {
|
|
|
|
"/Names": {
|
|
|
|
"/Dests": "107 0 R"
|
|
|
|
},
|
|
|
|
"/Outlines": "2 0 R",
|
|
|
|
"/PageMode": "/UseOutlines",
|
|
|
|
"/Pages": "3 0 R",
|
|
|
|
"/Type": "/Catalog"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"10 0 R": {
|
|
|
|
"/Contents": "48 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"100 0 R": {
|
|
|
|
"/Count": -2,
|
|
|
|
"/Dest": [
|
|
|
|
"18 0 R",
|
|
|
|
"/FitV",
|
|
|
|
100
|
|
|
|
],
|
|
|
|
"/First": "104 0 R",
|
|
|
|
"/Last": "105 0 R",
|
|
|
|
"/Next": "101 0 R",
|
|
|
|
"/Parent": "36 0 R",
|
|
|
|
"/Title": "Biherbadem 1.1.1 -> 12: /FitV 100",
|
|
|
|
"/Type": "/Outline"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"101 0 R": {
|
|
|
|
"/Count": 1,
|
|
|
|
"/Dest": [
|
|
|
|
"18 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"/First": "106 0 R",
|
|
|
|
"/Last": "106 0 R",
|
|
|
|
"/Parent": "36 0 R",
|
|
|
|
"/Prev": "100 0 R",
|
|
|
|
"/Title": "Gawehwehweh 1.1.2 -> 12: /XYZ null null null",
|
|
|
|
"/Type": "/Outline"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"102 0 R": {
|
|
|
|
"/Dest": "gabeebee",
|
|
|
|
"/Next": "103 0 R",
|
|
|
|
"/Parent": "37 0 R",
|
|
|
|
"/Title": "Gabeebeebee (name) 1.2.1 -> 1: /FitR 66 714 180 770",
|
|
|
|
"/Type": "/Outline"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"103 0 R": {
|
|
|
|
"/A": {
|
|
|
|
"/D": [
|
|
|
|
"6 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"/S": "/GoTo",
|
|
|
|
"/Type": "/Action"
|
|
|
|
},
|
|
|
|
"/Parent": "37 0 R",
|
|
|
|
"/Prev": "102 0 R",
|
|
|
|
"/Title": "Merschqaberschq (A) 1.2.2 -> 0: /XYZ null null null",
|
|
|
|
"/Type": "/Outline"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"104 0 R": {
|
|
|
|
"/A": {
|
|
|
|
"/D": "glarp",
|
|
|
|
"/S": "/GoTo",
|
|
|
|
"/Type": "/Action"
|
|
|
|
},
|
|
|
|
"/Next": "105 0 R",
|
|
|
|
"/Parent": "100 0 R",
|
|
|
|
"/Title": "Glarpenspliel (A, name) 1.1.1.1 -> 18: /XYZ null null null",
|
|
|
|
"/Type": "/Outline"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"105 0 R": {
|
|
|
|
"/Dest": [
|
|
|
|
"25 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"/Parent": "100 0 R",
|
|
|
|
"/Prev": "104 0 R",
|
|
|
|
"/Title": "Hagoogamagoogle 1.1.1.2 -> 19: /XYZ null null null",
|
|
|
|
"/Type": "/Outline"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"106 0 R": {
|
|
|
|
"/Dest": "108 0 R",
|
|
|
|
"/Parent": "101 0 R",
|
|
|
|
"/Title": "Jawarnianbvarwash 1.1.2.1 -> 22: /XYZ null null null",
|
|
|
|
"/Type": "/Outline"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"107 0 R": {
|
|
|
|
"/Names": [
|
|
|
|
"gabeebee",
|
|
|
|
[
|
|
|
|
"7 0 R",
|
|
|
|
"/FitR",
|
|
|
|
66,
|
|
|
|
714,
|
|
|
|
180,
|
|
|
|
770
|
|
|
|
],
|
|
|
|
"glarp",
|
|
|
|
[
|
|
|
|
"24 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
]
|
|
|
|
]
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"108 0 R": [
|
|
|
|
"28 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"11 0 R": {
|
|
|
|
"/Contents": "50 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"12 0 R": {
|
|
|
|
"/Contents": "52 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"13 0 R": {
|
|
|
|
"/Contents": "54 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"14 0 R": {
|
|
|
|
"/Contents": "56 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"15 0 R": {
|
|
|
|
"/Contents": "58 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"16 0 R": {
|
|
|
|
"/Contents": "60 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"17 0 R": {
|
|
|
|
"/Contents": "62 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"18 0 R": {
|
|
|
|
"/Contents": "64 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"19 0 R": {
|
|
|
|
"/Contents": "66 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"2 0 R": {
|
|
|
|
"/Count": 6,
|
|
|
|
"/First": "4 0 R",
|
|
|
|
"/Last": "5 0 R",
|
|
|
|
"/Type": "/Outlines"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"20 0 R": {
|
|
|
|
"/Contents": "68 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"21 0 R": {
|
|
|
|
"/Contents": "70 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"22 0 R": {
|
|
|
|
"/Contents": "72 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"23 0 R": {
|
|
|
|
"/Contents": "74 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"24 0 R": {
|
|
|
|
"/Contents": "76 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"25 0 R": {
|
|
|
|
"/Contents": "78 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"26 0 R": {
|
|
|
|
"/Contents": "80 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"27 0 R": {
|
|
|
|
"/Contents": "82 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"28 0 R": {
|
|
|
|
"/Contents": "84 0 R",
|
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
2020-04-04 21:59:53 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"29 0 R": {
|
|
|
|
"/Contents": "86 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"3 0 R": {
|
|
|
|
"/Count": 30,
|
|
|
|
"/Kids": [
|
|
|
|
"6 0 R",
|
|
|
|
"7 0 R",
|
|
|
|
"8 0 R",
|
|
|
|
"9 0 R",
|
|
|
|
"10 0 R",
|
|
|
|
"11 0 R",
|
|
|
|
"12 0 R",
|
|
|
|
"13 0 R",
|
|
|
|
"14 0 R",
|
|
|
|
"15 0 R",
|
|
|
|
"16 0 R",
|
|
|
|
"17 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"18 0 R",
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"19 0 R",
|
|
|
|
"20 0 R",
|
|
|
|
"21 0 R",
|
|
|
|
"22 0 R",
|
|
|
|
"23 0 R",
|
|
|
|
"24 0 R",
|
|
|
|
"25 0 R",
|
|
|
|
"26 0 R",
|
|
|
|
"27 0 R",
|
|
|
|
"28 0 R",
|
|
|
|
"29 0 R",
|
|
|
|
"30 0 R",
|
|
|
|
"31 0 R",
|
|
|
|
"32 0 R",
|
|
|
|
"33 0 R",
|
|
|
|
"34 0 R",
|
|
|
|
"35 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
],
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"/Type": "/Pages"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"30 0 R": {
|
|
|
|
"/Contents": "88 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"31 0 R": {
|
|
|
|
"/Contents": "90 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"32 0 R": {
|
|
|
|
"/Contents": "92 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"33 0 R": {
|
|
|
|
"/Contents": "94 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"34 0 R": {
|
|
|
|
"/Contents": "96 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"35 0 R": {
|
|
|
|
"/Contents": "98 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"36 0 R": {
|
|
|
|
"/Count": -3,
|
|
|
|
"/Dest": [
|
|
|
|
"17 0 R",
|
|
|
|
"/Fit"
|
|
|
|
],
|
|
|
|
"/First": "100 0 R",
|
|
|
|
"/Last": "101 0 R",
|
|
|
|
"/Next": "37 0 R",
|
|
|
|
"/Parent": "4 0 R",
|
|
|
|
"/Title": "Mern 1.1 -> 11: /Fit",
|
|
|
|
"/Type": "/Outline"
|
|
|
|
},
|
|
|
|
"37 0 R": {
|
|
|
|
"/Count": 2,
|
|
|
|
"/Dest": [
|
|
|
|
"19 0 R",
|
|
|
|
"/FitH",
|
2018-12-23 16:21:37 +00:00
|
|
|
792
|
|
|
|
],
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"/First": "102 0 R",
|
|
|
|
"/Last": "103 0 R",
|
|
|
|
"/Parent": "4 0 R",
|
|
|
|
"/Prev": "36 0 R",
|
|
|
|
"/Title": "Squash ÷πʬ÷ 1.2 -> 13: /FitH 792",
|
|
|
|
"/Type": "/Outline"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"38 0 R": {
|
|
|
|
"/Length": "39 0 R"
|
|
|
|
},
|
|
|
|
"39 0 R": 45,
|
|
|
|
"4 0 R": {
|
|
|
|
"/Count": 4,
|
|
|
|
"/Dest": [
|
|
|
|
"11 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null
|
|
|
|
],
|
|
|
|
"/First": "36 0 R",
|
|
|
|
"/Last": "37 0 R",
|
|
|
|
"/Next": "5 0 R",
|
|
|
|
"/Parent": "2 0 R",
|
|
|
|
"/Title": "Potato 1 -> 5: /XYZ null null null",
|
|
|
|
"/Type": "/Outline"
|
|
|
|
},
|
|
|
|
"40 0 R": {
|
|
|
|
"/BaseFont": "/Helvetica",
|
|
|
|
"/Encoding": "/WinAnsiEncoding",
|
|
|
|
"/Name": "/F1",
|
|
|
|
"/Subtype": "/Type1",
|
|
|
|
"/Type": "/Font"
|
|
|
|
},
|
|
|
|
"41 0 R": [
|
|
|
|
"/PDF",
|
|
|
|
"/Text"
|
|
|
|
],
|
|
|
|
"42 0 R": {
|
|
|
|
"/Length": "43 0 R"
|
|
|
|
},
|
|
|
|
"43 0 R": 45,
|
|
|
|
"44 0 R": {
|
|
|
|
"/Length": "45 0 R"
|
|
|
|
},
|
|
|
|
"45 0 R": 45,
|
|
|
|
"46 0 R": {
|
|
|
|
"/Length": "47 0 R"
|
|
|
|
},
|
|
|
|
"47 0 R": 45,
|
|
|
|
"48 0 R": {
|
|
|
|
"/Length": "49 0 R"
|
|
|
|
},
|
|
|
|
"49 0 R": 45,
|
|
|
|
"5 0 R": {
|
|
|
|
"/Dest": [
|
|
|
|
"21 0 R",
|
|
|
|
"/XYZ",
|
|
|
|
66,
|
|
|
|
756,
|
|
|
|
3
|
|
|
|
],
|
|
|
|
"/Parent": "2 0 R",
|
|
|
|
"/Prev": "4 0 R",
|
|
|
|
"/Title": "Salad 2 -> 15: /XYZ 66 756 3",
|
|
|
|
"/Type": "/Outline"
|
|
|
|
},
|
|
|
|
"50 0 R": {
|
|
|
|
"/Length": "51 0 R"
|
|
|
|
},
|
|
|
|
"51 0 R": 45,
|
|
|
|
"52 0 R": {
|
|
|
|
"/Length": "53 0 R"
|
|
|
|
},
|
|
|
|
"53 0 R": 45,
|
|
|
|
"54 0 R": {
|
|
|
|
"/Length": "55 0 R"
|
|
|
|
},
|
|
|
|
"55 0 R": 45,
|
|
|
|
"56 0 R": {
|
|
|
|
"/Length": "57 0 R"
|
|
|
|
},
|
|
|
|
"57 0 R": 45,
|
|
|
|
"58 0 R": {
|
|
|
|
"/Length": "59 0 R"
|
|
|
|
},
|
|
|
|
"59 0 R": 45,
|
|
|
|
"6 0 R": {
|
|
|
|
"/Contents": "38 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"60 0 R": {
|
|
|
|
"/Length": "61 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"61 0 R": 46,
|
|
|
|
"62 0 R": {
|
|
|
|
"/Length": "63 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"63 0 R": 46,
|
|
|
|
"64 0 R": {
|
|
|
|
"/Length": "65 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"65 0 R": 46,
|
|
|
|
"66 0 R": {
|
|
|
|
"/Length": "67 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"67 0 R": 46,
|
|
|
|
"68 0 R": {
|
|
|
|
"/Length": "69 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"69 0 R": 46,
|
|
|
|
"7 0 R": {
|
|
|
|
"/Contents": "42 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"70 0 R": {
|
|
|
|
"/Length": "71 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"71 0 R": 46,
|
|
|
|
"72 0 R": {
|
|
|
|
"/Length": "73 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"73 0 R": 46,
|
|
|
|
"74 0 R": {
|
|
|
|
"/Length": "75 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"75 0 R": 46,
|
|
|
|
"76 0 R": {
|
|
|
|
"/Length": "77 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"77 0 R": 46,
|
|
|
|
"78 0 R": {
|
|
|
|
"/Length": "79 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"79 0 R": 46,
|
|
|
|
"8 0 R": {
|
|
|
|
"/Contents": "44 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"80 0 R": {
|
|
|
|
"/Length": "81 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"81 0 R": 46,
|
|
|
|
"82 0 R": {
|
|
|
|
"/Length": "83 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"83 0 R": 46,
|
|
|
|
"84 0 R": {
|
|
|
|
"/Length": "85 0 R"
|
|
|
|
},
|
|
|
|
"85 0 R": 46,
|
|
|
|
"86 0 R": {
|
|
|
|
"/Length": "87 0 R"
|
|
|
|
},
|
|
|
|
"87 0 R": 46,
|
|
|
|
"88 0 R": {
|
|
|
|
"/Length": "89 0 R"
|
|
|
|
},
|
|
|
|
"89 0 R": 46,
|
|
|
|
"9 0 R": {
|
|
|
|
"/Contents": "46 0 R",
|
2018-12-23 16:21:37 +00:00
|
|
|
"/MediaBox": [
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
612,
|
|
|
|
792
|
|
|
|
],
|
|
|
|
"/Parent": "3 0 R",
|
|
|
|
"/Resources": {
|
|
|
|
"/Font": {
|
|
|
|
"/F1": "40 0 R"
|
|
|
|
},
|
|
|
|
"/ProcSet": "41 0 R"
|
|
|
|
},
|
|
|
|
"/Type": "/Page"
|
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"90 0 R": {
|
|
|
|
"/Length": "91 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"91 0 R": 46,
|
|
|
|
"92 0 R": {
|
|
|
|
"/Length": "93 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"93 0 R": 46,
|
|
|
|
"94 0 R": {
|
|
|
|
"/Length": "95 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"95 0 R": 46,
|
|
|
|
"96 0 R": {
|
|
|
|
"/Length": "97 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"97 0 R": 46,
|
|
|
|
"98 0 R": {
|
|
|
|
"/Length": "99 0 R"
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"99 0 R": 46,
|
|
|
|
"trailer": {
|
|
|
|
"/ID": [
|
|
|
|
"Õ+\f\u0017Â\u0016Pib®gC¯ì&\u000f",
|
|
|
|
"Õ+\f\u0017Â\u0016Pib®gC¯ì&\u000f"
|
2018-12-23 16:21:37 +00:00
|
|
|
],
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"/Root": "1 0 R",
|
|
|
|
"/Size": 109
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"objectinfo": {
|
|
|
|
"1 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"10 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"100 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"101 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"102 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"103 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"104 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"105 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"106 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"107 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"108 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"11 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"12 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"13 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"14 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"15 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"16 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"17 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"18 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"19 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"2 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"20 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"21 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"22 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"23 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"24 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"25 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"26 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"27 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"28 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"29 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"3 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"30 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"31 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"32 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"33 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"34 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"35 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"36 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"37 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"38 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 45
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"39 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"4 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"40 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"41 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"42 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 45
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"43 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"44 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 45
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"45 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"46 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 45
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"47 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"48 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 45
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"49 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"5 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"50 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 45
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"51 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"52 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 45
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"53 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"54 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 45
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"55 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"56 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 45
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"57 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"58 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 45
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"59 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"6 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"60 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"61 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"62 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"63 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"64 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"65 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"66 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"67 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"68 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"69 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"7 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"70 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"71 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"72 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"73 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
|
|
|
},
|
|
|
|
"74 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"75 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"76 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"77 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"78 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"79 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"8 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"80 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"81 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"82 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"83 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"84 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"85 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"86 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"87 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"88 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"89 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"9 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"90 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"91 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"92 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"93 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"94 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"95 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"96 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"97 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"98 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": true,
|
|
|
|
"length": 46
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
},
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
"99 0 R": {
|
|
|
|
"stream": {
|
|
|
|
"filter": null,
|
|
|
|
"is": false,
|
|
|
|
"length": null
|
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
}
|
Top-level json: write incrementally
This commit just changes the order in which fields are written to the
json without changing their content. All the json files in the test
suite were modified with this script to ensure that we didn't get any
changes other than ordering.
----------
#!/usr/bin/env python3
import json
import sys
def json_dumps(data):
return json.dumps(data, ensure_ascii=False,
indent=2, separators=(',', ': '))
for filename in sys.argv[1:]:
with open(filename, 'r') as f:
data = json.loads(f.read())
newdata = {}
for i in ('version', 'parameters', 'pages', 'pagelabels',
'acroform', 'attachments', 'encrypt', 'outlines',
'objects', 'objectinfo'):
if i in data:
newdata[i] = data[i]
print(json_dumps(newdata))
----------
2022-05-06 22:25:59 +00:00
|
|
|
}
|
2018-12-23 16:21:37 +00:00
|
|
|
}
|