@futpib/parser 1.0.0 → 1.0.2

package/src/inputReader.test.ts

@@ -1,10 +1,12 @@
 import test from 'ava';
 import { InputReaderImplementation } from './inputReader.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { ParserImplementationError } from './parserError.js';
+import { toAsyncIterable } from './toAsyncIterable.js';
+import { InputReaderState } from './inputReaderState.js';
 
 test('inputReader', async t => {
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield '';
 		yield 'abc';
 		yield 'def';
@@ -46,8 +48,55 @@ test('inputReader', async t => {
 	t.is(await inputReader.peek(0), undefined);
 });
 
+test('inputReader peekSequence', async t => {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
+		yield '';
+		yield 'abc';
+		yield 'def';
+		yield '';
+		yield 'gh';
+	})());
+
+	t.is(await inputReader.peekSequence(0, 0), '');
+	t.is(await inputReader.peekSequence(0, 1), 'a');
+
+	inputReader.skip(0);
+
+	t.is(await inputReader.peekSequence(1, 2), 'b');
+
+	inputReader.skip(1);
+
+	t.is(await inputReader.peekSequence(1, 7), 'bcdefgh'.slice(1, 7));
+	t.is(await inputReader.peekSequence(1, 8), undefined);
+
+	inputReader.skip(6);
+
+	t.is(await inputReader.peekSequence(0, 0), '');
+	t.is(await inputReader.peekSequence(0, 1), 'h');
+	t.is(await inputReader.peekSequence(1, 2), undefined);
+	t.is(await inputReader.peekSequence(2, 2), undefined);
+
+	inputReader.skip(1);
+
+	t.is(await inputReader.peekSequence(0, 0), '');
+	t.is(await inputReader.peekSequence(0, 1), undefined);
+	t.is(await inputReader.peekSequence(1, 1), undefined);
+
+	inputReader.skip(0);
+
+	t.is(await inputReader.peekSequence(0, 0), '');
+	t.is(await inputReader.peekSequence(0, 1), undefined);
+	t.is(await inputReader.peekSequence(1, 1), undefined);
+
+	inputReader.skip(1);
+
+	t.is(await inputReader.peekSequence(0, 0), undefined);
+	t.is(await inputReader.peekSequence(0, 1), undefined);
+	t.is(await inputReader.peekSequence(1, 1), undefined);
+});
+
 test('inputReader.peek concurrent', async t => {
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
 	})());
 
@@ -68,8 +117,66 @@ test('inputReader.peek concurrent', async t => {
 	t.deepEqual(peeks, [ 'a', 'a', 'a', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h' ]);
 });
 
+test('inputReader.peekSequence concurrent', async t => {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
+		yield * 'abcdefgh';
+	})());
+
+	const peeks = await Promise.all([1, 2, 3].flatMap(length => [
+		inputReader.peekSequence(0, 0 + length),
+		inputReader.peekSequence(0, 0 + length),
+		inputReader.peekSequence(0, 0 + length),
+		inputReader.peekSequence(0, 0 + length),
+		inputReader.peekSequence(1, 1 + length),
+		inputReader.peekSequence(2, 2 + length),
+		inputReader.peekSequence(3, 3 + length),
+		inputReader.peekSequence(4, 4 + length),
+		inputReader.peekSequence(5, 5 + length),
+		inputReader.peekSequence(6, 6 + length),
+		inputReader.peekSequence(7, 7 + length),
+	]));
+
+	t.deepEqual(peeks, [
+		'a',
+		'a',
+		'a',
+		'a',
+		'b',
+		'c',
+		'd',
+		'e',
+		'f',
+		'g',
+		'h',
+
+		'ab',
+		'ab',
+		'ab',
+		'ab',
+		'bc',
+		'cd',
+		'de',
+		'ef',
+		'fg',
+		'gh',
+		undefined,
+
+		'abc',
+		'abc',
+		'abc',
+		'abc',
+		'bcd',
+		'cde',
+		'def',
+		'efg',
+		'fgh',
+		undefined,
+		undefined,
+	]);
+});
+
 test('inputReader skip while peeking', async t => {
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
 	})());
 
@@ -77,14 +184,39 @@ test('inputReader skip while peeking', async t => {
 
 	inputReader.skip(1);
 
+	const peekAfterSkipPromise = inputReader.peek(0);
+	const peekSequenceAfterSkipPromise = inputReader.peekSequence(0, 5);
+
 	t.is(await peekPromise, 'a');
 	t.is(await inputReader.peek(0), 'b');
+
+	t.is(await peekAfterSkipPromise, 'b');
+	t.is(await peekSequenceAfterSkipPromise, 'bcdef');
+});
+
+test('inputReader skip while peeking sequence', async t => {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
+		yield * 'abcdefgh';
+	})());
+
+	const peekPromise = inputReader.peekSequence(1, 5);
+
+	inputReader.skip(1);
+
+	const peekAfterSkipPromise = inputReader.peek(0);
+	const peekSequenceAfterSkipPromise = inputReader.peekSequence(0, 4);
+
+	t.is(await peekPromise, 'bcde', 'peekPromise');
+	t.is(await inputReader.peekSequence(0, 4), 'bcde', 'inputReader.peekSequence(0, 4)');
+
+	t.is(await peekAfterSkipPromise, 'b', 'peekAfterSkipPromise');
+	t.is(await peekSequenceAfterSkipPromise, 'bcde', 'peekSequenceAfterSkipPromise');
 });
 
 test('inputReader.lookahead', async t => {
 	let read = 0;
 
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		for (const character of 'abcdefgh') {
 			read++;
 			yield character;
@@ -180,7 +312,7 @@ test('inputReader.lookahead', async t => {
 test('inputReader.lookahead concurrent', async t => {
 	let read = 0;
 
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		for (const character of 'abcdefgh') {
 			read++;
 			yield character;
@@ -211,7 +343,7 @@ test('inputReader.lookahead concurrent', async t => {
 test('inputReader.lookahead skip position', async t => {
 	let read = 0;
 
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		for (const character of 'abcdefgh') {
 			read++;
 			yield character;
@@ -236,3 +368,80 @@ test('inputReader.lookahead skip position', async t => {
 	t.is(await lookahead.peek(0), 'c');
 	t.is(await lookahead1.peek(0), 'd');
 });
+
+const END_OF_CONSUMED_SEQUENCES = Symbol('END_OF_CONSUMED_SEQUENCES');
+const END_OF_BUFFERED_SEQUENCES = Symbol('END_OF_BUFFERED_SEQUENCES');
+
+async function inputReaderStateToArray<Sequence>({
+	unconsumedBufferedSequences,
+	consumedBufferedSequences,
+	unbufferedSequences,
+}: InputReaderState<Sequence>): Promise<(Sequence | typeof END_OF_CONSUMED_SEQUENCES | typeof END_OF_BUFFERED_SEQUENCES)[]> {
+	const unconsumedBufferedSequencesArray = unconsumedBufferedSequences.slice();
+	const consumedBufferedSequencesArray = consumedBufferedSequences.slice();
+
+	const unbufferedSequencesArray = [];
+	if (unbufferedSequences) {
+		for await (const sequence of toAsyncIterable(unbufferedSequences)) {
+			unbufferedSequencesArray.push(sequence);
+		}
+	}
+
+	return [
+		...consumedBufferedSequencesArray,
+		END_OF_CONSUMED_SEQUENCES,
+		...unconsumedBufferedSequencesArray,
+		END_OF_BUFFERED_SEQUENCES,
+		...unbufferedSequencesArray,
+	];
+}
+
+for (const [
+	input,
+	position,
+	expected,
+] of [
+	[
+		[ '', 'abc', 'def', '', 'gh' ],
+		0,
+		[ END_OF_CONSUMED_SEQUENCES, 'abc', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh' ],
+	],
+	[
+		[ '', 'abc', 'def', '', 'gh' ],
+		1,
+		[ 'a', END_OF_CONSUMED_SEQUENCES, 'bc', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh' ],
+	],
+	[
+		[ '', 'abc', 'def', '', 'gh' ],
+		2,
+		[ 'ab', END_OF_CONSUMED_SEQUENCES, 'c', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh' ],
+	],
+	[
+		[ '', 'abc', 'def', '', 'gh' ],
+		3,
+		[ END_OF_CONSUMED_SEQUENCES, 'def', END_OF_BUFFERED_SEQUENCES, '', 'gh' ],
+	],
+	[
+		[ '', 'abc', 'def', '', 'gh' ],
+		4,
+		[ 'd', END_OF_CONSUMED_SEQUENCES, 'ef', END_OF_BUFFERED_SEQUENCES, '', 'gh' ],
+	],
+	[
+		[ '', 'abc', 'def', '', 'gh' ],
+		8,
+		[ END_OF_CONSUMED_SEQUENCES, END_OF_BUFFERED_SEQUENCES ],
+	],
+] as const) {
+	test('inputReader.toInputReaderState ' + JSON.stringify({ input, position }), async t => {
+		const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
+			yield * input;
+		})());
+
+		inputReader.skip(position);
+		await inputReader.peek(0);
+
+		const actual = await inputReaderStateToArray(inputReader.toInputReaderState());
+
+		t.deepEqual(actual, expected);
+	});
+}

package/src/inputReader.ts

@@ -1,16 +1,20 @@
 import PromiseMutex from 'p-mutex';
 import invariant from 'invariant';
 import { type SequenceBuffer, SequenceBufferImplementation } from './sequenceBuffer.js';
-import { type InputCompanion } from './inputCompanion.js';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { InputReaderState } from './inputReaderState.js';
 
 export type InputReader<Sequence, Element> = {
 	get position(): number;
 
 	peek(offset: number): Promise<Element | undefined>;
+	peekSequence(start: number, end: number): Promise<Sequence | undefined>;
 	skip(offset: number): void;
 
 	lookahead(): InputReader<Sequence, Element>;
+
+	toInputReaderState(): InputReaderState<Sequence>;
 };
 
 let inputReaderId = 0;
@@ -20,16 +24,17 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 
 	private _position = 0;
 	private _uncommitedSkipOffset = 0;
+	private _inputAsyncIteratorDone = false;
 
 	private readonly _promiseMutex = new PromiseMutex();
 
 	private readonly _sequenceBuffer: SequenceBuffer<Sequence, Element>;
 
 	constructor(
-		private readonly _inputCompanion: InputCompanion<Sequence, Element>,
+		private readonly _parserInputCompanion: ParserInputCompanion<Sequence, Element>,
 		private readonly _inputAsyncIterator: AsyncIterator<Sequence>,
 	) {
-		this._sequenceBuffer = new SequenceBufferImplementation<Sequence, Element>(this._inputCompanion);
+		this._sequenceBuffer = new SequenceBufferImplementation<Sequence, Element>(this._parserInputCompanion);
 	}
 
 	get [Symbol.toStringTag]() {
@@ -66,18 +71,20 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 				const inputIteratorResult = await this._inputAsyncIterator.next();
 
 				if (inputIteratorResult.done) {
+					this._inputAsyncIteratorDone = true;
+
 					return undefined;
 				}
 
 				parserImplementationInvariant(
-					this._inputCompanion.is(inputIteratorResult.value),
+					this._parserInputCompanion.is(inputIteratorResult.value),
 					[
 						'Input iterator result value (%s) is of unexpected type.',
 						'Expected a sequence (a chunk of input) recognized by the input companion (%s).',
 						'You may have provided a wrong input companion for the input.',
 					],
 					inputIteratorResult.value,
-					this._inputCompanion.constructor.name,
+					this._parserInputCompanion.constructor.name,
 				);
 
 				this._sequenceBuffer.push(inputIteratorResult.value);
@@ -85,6 +92,47 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 		});
 	}
 
+	async peekSequence(start: number, end: number): Promise<Sequence | undefined> {
+		parserImplementationInvariant(
+			start >= 0,
+			'start (%s) >= 0',
+			start,
+		);
+		parserImplementationInvariant(
+			end >= start,
+			'end (%s) >= start (%s)',
+			start,
+			end,
+		);
+		parserImplementationInvariant(
+			Number.isSafeInteger(start),
+			'start (%s) is not a safe integer',
+			start,
+		);
+		parserImplementationInvariant(
+			Number.isSafeInteger(end),
+			'end (%s) is not a safe integer',
+			end,
+		);
+
+		start += this._uncommitedSkipOffset;
+		end += this._uncommitedSkipOffset;
+
+		const sequence = this._sequenceBuffer.peekSequence(start, end);
+
+		if (sequence !== undefined) {
+			return sequence;
+		}
+
+		const lastElement = await this.peek(Math.max(0, end - 1));
+
+		if (lastElement === undefined) {
+			return undefined;
+		}
+
+		return this._sequenceBuffer.peekSequence(start, end);
+	}
+
 	skip(offset: number) {
 		parserImplementationInvariant(offset >= 0, 'offset >= 0');
 
@@ -101,6 +149,20 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 	lookahead(): InputReader<Sequence, Element> {
 		return new InputReaderLookaheadImplementation(this);
 	}
+
+	toInputReaderState() {
+		const {
+			consumedBufferedSequences,
+			unconsumedBufferedSequences,
+		} = this._sequenceBuffer.toSequenceBufferState();
+
+		return {
+			consumedBufferedSequences,
+			unconsumedBufferedSequences,
+			unbufferedSequences: this._inputAsyncIteratorDone ? undefined : this._inputAsyncIterator,
+			position: this._position,
+		};
+	}
 }
 
 class InputReaderLookaheadImplementation<Sequence, Element> implements InputReader<Sequence, Element> {
@@ -134,6 +196,15 @@ class InputReaderLookaheadImplementation<Sequence, Element> implements InputRead
 		return this._inputReader.peek(this._offset + offset);
 	}
 
+	async peekSequence(start: number, end: number): Promise<Sequence | undefined> {
+		const inputReaderMovedForward = this._inputReader.position - this._initialInputReaderPosition;
+
+		this._initialInputReaderPosition = this._inputReader.position;
+		this._offset -= inputReaderMovedForward;
+
+		return this._inputReader.peekSequence(this._offset + start, this._offset + end);
+	}
+
 	skip(offset: number) {
 		parserImplementationInvariant(offset >= 0, 'offset >= 0');
 
@@ -156,4 +227,8 @@ class InputReaderLookaheadImplementation<Sequence, Element> implements InputRead
 
 		return lookahead;
 	}
+
+	toInputReaderState() {
+		return invariant(false, 'Not implemented');
+	}
 }

package/src/inputReaderState.ts

@@ -0,0 +1,33 @@
+export type InputReaderState<Sequence> = {
+	position: number;
+	consumedBufferedSequences: Sequence[];
+	unconsumedBufferedSequences: Sequence[];
+	unbufferedSequences: undefined | AsyncIterator<Sequence>;
+};
+
+export const inputReaderStateCompanion = {
+	isDone<Sequence>({
+		unconsumedBufferedSequences,
+		unbufferedSequences,
+	}: InputReaderState<Sequence>): boolean {
+		return (
+			unconsumedBufferedSequences.length === 0
+				&& unbufferedSequences === undefined
+		);
+	},
+
+	async * toRemainingInputAsyncIterator<Sequence>({
+		unconsumedBufferedSequences,
+		unbufferedSequences,
+	}: InputReaderState<Sequence>): AsyncIterable<Sequence> {
+		yield * unconsumedBufferedSequences;
+
+		if (unbufferedSequences !== undefined) {
+			yield * {
+				[Symbol.asyncIterator]() {
+					return unbufferedSequences;
+				},
+			};
+		}
+	},
+};

package/src/inspect.ts

@@ -0,0 +1,9 @@
+import { inspect as nodeInspect } from 'node:util';
+
+export const inspect = (value: unknown) => {
+	if (value instanceof Uint8Array) {
+		value = Buffer.from(value);
+	}
+
+	return nodeInspect(value);
+}

package/src/javaKeyStoreParser.test.ts

@@ -0,0 +1,22 @@
+import test from 'ava';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import { javaKeyStoreParser } from './javaKeyStoreParser.js';
+import { fetchCid } from './fetchCid.js';
+
+for (const javaKeyStoreCid of [
+	'bafkreig6k53b6p7bdvfjxc5mcb4qv3mffqls5ymqerxkqd6ih2xy5cs3n4',
+]) {
+	test(
+		'javaKeyStore ' + javaKeyStoreCid,
+		async t => {
+			const javaKeyStoreStream = await fetchCid(javaKeyStoreCid);
+
+			const actual = await runParser(javaKeyStoreParser, javaKeyStoreStream, uint8ArrayParserInputCompanion, {
+				errorJoinMode: 'all',
+			});
+
+			t.snapshot(actual);
+		},
+	);
+}

package/src/javaKeyStoreParser.test.ts.md

@@ -0,0 +1,103 @@
+# Snapshot report for `src/javaKeyStoreParser.test.ts`
+
+The actual snapshot is saved in `javaKeyStoreParser.test.ts.snap`.
+
+Generated by [AVA](https://avajs.dev).
+
+## javaKeyStore bafkreig6k53b6p7bdvfjxc5mcb4qv3mffqls5ymqerxkqd6ih2xy5cs3n4
+
+> Snapshot 1
+
+    {
+      entries: [
+        {
+          alias: 'alias_name',
+          certificateChain: [
+            {
+              certificate: Uint8Array [
+                3082037d 30820265 a0030201 02020862 1867f6fc b0aab430 0d06092a 864886f7
+                0d01010b 0500306c 3110300e 06035504 06130755 6e6b6e6f 776e3110 300e0603
+                55040813 07556e6b 6e6f776e 3110300e 06035504 07130755 6e6b6e6f 776e3110
+                300e0603 55040a13 07556e6b 6e6f776e 3110300e 06035504 0b130755 6e6b6e6f
+                776e3110 300e0603 55040313 07556e6b 6e6f776e 3020170d 32343132 30383133
+                33343232 5a180f32 30353230 34323531 33333432 325a306c 3110300e 06035504
+                06130755 6e6b6e6f 776e3110 300e0603 55040813 07556e6b 6e6f776e 3110300e
+                06035504 07130755 6e6b6e6f 776e3110 300e0603 55040a13 07556e6b 6e6f776e
+                3110300e 06035504 0b130755 6e6b6e6f 776e3110 300e0603 55040313 07556e6b
+                6e6f776e 30820122 300d0609 2a864886 f70d0101 01050003 82010f00 3082010a
+                02820101 00c4d6d9 6e38ae16 54e1f3a6 d7b68d49 23a01024 ded06818 5e88835e
+                2edf5cdc 1839f148 864f20fc 355655a5 f1023e4f 6fced37e 0a55d77c d206c4f4
+                e6a7041e d16a439a 38bd824e 29e4d407 16a4a154 3e952838 79b5c1e6 1e376927
+                9ed92d62 c94bfd06 261b3034 1c5420c7 ca6d7925 8deafdb3 252ada5f 2a571b11
+                fb265869 d2c9335b ca9d2c06 5ce9586c 006b371b c555c122 d734be38 e57486b5
+                ccad06c2 b532dd4f 1a025e04 2bdea06a 1056367c 92b2db6e 9c8f6353 1d4d28fd
+                d6d78a45 9fcb5ada 16a9988b 032d6c69 6d63f739 9d5664b8 c0adf5a2 f748e177
+                e019a4a3 23a7fd10 dcd2be1b 6b8cbdcf eb7e76cd f35698a1 2c77b508 0d1a7884
+                ce8f1980 2f020301 0001a321 301f301d 0603551d 0e041604 14fdef9a ebf342b2
+                3bb007b1 6de4e2a8 0e953421 d4300d06 092a8648 86f70d01 010b0500 03820101
+                00c12e4e 03282b2f 36ee57a6 144d1774 55e08149 ce8e5b46 5f340757 7b301880
+                f3e7c4bd 564c5aa6 5202100e b819ae3a fb8c4adf c9e13cdc 82fdab8d c3cab7d7
+                68f01c41 18f67b0b 534eeb5c ab7ebeec af4cadd2 df3efe7c c4ec9311 9c3ec17e
+                3152746f 39d99717 042557f9 eb8aa2fa e87eb332 833c75db 1d373e50 2ea3b3ef
+                9bb847c0 8190fda7 318a0cac 374b507c 5db948e4 65c9ae38 4b304b8d d5c62014
+                ad01857b 5548dec0 b4c5b61f 0b21597a ede13707 e701dc44 933bb097 832e5158
+                2d19c606 a2b540ec bb501ffc 5d772e08 44e57a7f eb026278 c69e6160 8cddc2df
+                b56418b6 1cea3698 f86fa91d c7bd9e4b 83e80666 d343b087 7a0117a2 f8773fcc
+                31
+              ],
+              type: 'X.509',
+            },
+          ],
+          creationDate: Date 2024-12-08 13:34:25 771ms UTC {},
+          privateKey: Uint8Array [
+            308204fd 300e060a 2b060104 012a0211 01010500 048204e9 6bafd40a 4a5b9ba7
+            d71d60e8 3f9d1d2b e8f1a677 d30c00f9 8c27a431 cf19c6cf 01527d3c 23490657
+            9d30ee44 6f2a1c3d 8785c9e9 20cb403c 9c06bb6a 83eafd69 8a3e2a43 4a2340b1
+            873bf5d7 766a4003 935463f8 5894dd90 79c940b8 d7b908e9 5dc7b7e8 e01a9f55
+            7c31b465 cdf2b4e5 322f547c 74e28695 e49aff82 96144608 4e139e96 915022da
+            106a61b2 cda01a71 dd195aa2 d3db85e0 8d5e52b6 649e358e 38cc2b63 a95496e7
+            f13b35da a3812622 b6a8ca99 e25baf66 70cf30b6 3097794a 14385807 7f2ffd85
+            cd6c8ef9 4c87cd48 46cca8c1 9dc4c73e a62d6f0a 7fc8054f 1408c9b6 f7dd750b
+            595b6c60 2766bd8c db986cda 16829b4f a06f274f 5d540aac 814e5a50 9127bed4
+            a48dd702 f613b823 9218a9d0 344ba799 99e2caf2 8f9c976a 9db0fc39 d0d1c0a4
+            0338e5c2 03632ffb 5e58200a 3921a5bd 1516e598 f6e912aa 0f08129a f082088f
+            17165118 39fabef3 b6c93d25 1c35c8a5 b533546a 72e3dcb8 827b77b3 01b0bd60
+            a54ecae6 e37ab488 97ca7f26 014fe9f5 8b35c81e 5e201f05 43226ff7 fa41e019
+            3ed3f47a 92167c6c a691814d 4883471e 4ffdd7e5 66e32235 dfcbe212 99ef4559
+            d2b6fc5c 26e23964 e4c0ccf2 9ef4a0c1 9078ef4f 04ec1a8c 91916f0b 85bd18eb
+            1abe756c 9a90da9d 1293f95a db7edbc9 eb0aecd1 85ee554f 832dbb01 21dfacbf
+            12be629e 5b33e3b5 f3ebdcd1 69bc40b5 67607be4 d38e6a22 f8b520ab 6d498d23
+            a7af72f0 9a57690d c11113f8 744b77e2 b45b52a5 19e5cffe 3e19e106 ae2454d7
+            9741d01b 8cfbc4c0 16efaf4e d8ab96b3 bf04b7e1 81099b5f dcac9158 0636a33a
+            2ce348ba ddaeef30 0bb27d8a d762f9b1 0a87c57c 0787667f e7542cbb 4077ade1
+            c2784b03 fa590107 deaea210 59920506 472a5983 fdc7706e e99ec034 55b17fe8
+            8f8ed3a1 d43bde6e a392bbdd bdb81ff5 b6ad03de 8a46a97f 278f697a b0669db4
+            967ef9b8 7bca57f4 8507d655 5f77bce4 901010bc cf69106a 407481b0 efe8f5df
+            137aea5c cc6e1777 364809dd f39e2c80 437e11d4 692488ee 9760f10a 4b3078be
+            3f6b363d 25ccd315 4caee2d7 f29e44c9 3bb899fe 141e4233 b44a4dd8 6a7a3ab3
+            2ab7ecae 4c91bab1 a7223e88 d831ee3a 24fbca73 712dcd8c 22a22ea6 f74d52ff
+            52df9e06 c42e57cb 6e615094 52a6489a c985d992 38ed1861 f9c668d6 bedfa6b7
+            83f8f03f 66425389 fea1fd10 0cd78635 999194c9 54ea2233 99c8a384 7e034fe2
+            6be1e2b1 652ccb10 59c23b48 a34a4732 47b61a90 baa39965 db02b59d e5258a5e
+            6bd44e7b 46023f60 417c9a26 98d9435d cfed43cc c3235627 c4bc7589 bbbf520f
+            16480c66 8a355d3f aa4693db 499051be b85350d4 c45eb43f 7f09461c 882a4168
+            69135d31 db14dd3d bd49b28f 810f6cfc 70759172 66b79b43 951e020d 69bdb933
+            01f722f2 d77be629 8d0027be 96373dc2 e862792c 20894f6b ed8ec5ca 2b99fea5
+            4d37e8ca 01422458 025833bc 9bb4a8c8 491dee69 c8bb6b42 9eaa6bca 770b5a4d
+            95e9931e 12cffaa0 54566c76 7c323b6f f6f60e97 1e5c54fe eefa57f7 e6f6b352
+            d8f0f43e dc9b224a c7678d6b 35532593 6c1aac3b 4ae05907 4c70bb40 07373e8c
+            97126047 b3b23ae5 41e15db1 d251d5c5 e9a2dc51 6863ec2b ed2ad0b9 54d4ecc1
+            f184cba3 7e588d99 6be6caf1 72ba9771 650d92a7 3402ed51 4972e38e fb20b53e
+            1442e461 49054fc6 f6899e65 b02c968f 97884dd1 1e5b1bd6 d394ff8d a5155836
+            53d72788 e5de5454 5bbebefb 71b35c5d d63f9a1e 938210a8 d8f7e536 12494c5b
+            e5
+          ],
+          type: 'privateKey',
+        },
+      ],
+      hash: Uint8Array [
+        9bbf5a41 f2b3fcd4 a9ac77fe 0820317e 6a8f05e9
+      ],
+      implementation: 'JKS',
+      version: 2,
+    }