@futpib/parser 1.0.0 → 1.0.1

package/build/parserContext.js

@@ -1,17 +1,18 @@
+/* eslint-disable prefer-arrow-callback */
 import invariant from 'invariant';
-import { ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError } from './parserError.js';
-import { parserInvariant } from './parserInvariant.js';
+import { ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError, } from './parserError.js';
+import { customInvariant } from './customInvariant.js';
 let parserContextId = 0;
 export class ParserContextImplementation {
-    _inputCompanion;
+    _parserInputCompanion;
     _inputReader;
     _parentParserContext;
     _options;
     _id = parserContextId++;
     _depth;
     _exclusiveChildParserContext = undefined;
-    constructor(_inputCompanion, _inputReader, _parentParserContext = undefined, _options) {
-        this._inputCompanion = _inputCompanion;
+    constructor(_parserInputCompanion, _inputReader, _parentParserContext = undefined, _options) {
+        this._parserInputCompanion = _parserInputCompanion;
         this._inputReader = _inputReader;
         this._parentParserContext = _parentParserContext;
         this._options = _options;
@@ -30,13 +31,13 @@ export class ParserContextImplementation {
         ].join(' ');
     }
     from(elements) {
-        return this._inputCompanion.from(elements);
+        return this._parserInputCompanion.from(elements);
     }
     length(sequence) {
-        return this._inputCompanion.length(sequence);
+        return this._parserInputCompanion.length(sequence);
     }
     at(sequence, index) {
-        return this._inputCompanion.at(sequence, index);
+        return this._parserInputCompanion.at(sequence, index);
     }
     get position() {
         return this._inputReader.position;
@@ -65,7 +66,7 @@ export class ParserContextImplementation {
             debugger;
         }
         invariant(this.position === lookaheadInputReader.position, 'lookahead this.position (%s) === lookaheadInputReader.position (%s)', this.position, lookaheadInputReader.position);
-        const lookaheadParserContext = new ParserContextImplementation(this._inputCompanion, lookaheadInputReader, this, {
+        const lookaheadParserContext = new ParserContextImplementation(this._parserInputCompanion, lookaheadInputReader, this, {
             ...this._options,
             ...options,
             debugName: [
@@ -116,7 +117,7 @@ export class ParserContextImplementation {
     }
     invariant(value, format, ...formatArguments) {
         const parserContext = this;
-        return parserInvariant(function (message) {
+        return customInvariant(function (message) {
             return new ParserParsingInvariantError(message, parserContext._depth, parserContext.position);
         }, value, format, ...formatArguments);
     }
@@ -125,12 +126,12 @@ export class ParserContextImplementation {
         const errorJoinMode = this._options.errorJoinMode ?? 'none';
         const parserContext = this;
         if (errorJoinMode === 'none') {
-            return parserInvariant(function (message) {
+            return customInvariant(function (message) {
                 return new ParserParsingJoinNoneError(message, parserContext._depth, parserContext.position);
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'furthest') {
-            return parserInvariant(function (message) {
+            return customInvariant(function (message) {
                 let furthestPosition = 0;
                 let furthestChildErrors = [];
                 for (const childError of childErrors) {
@@ -154,7 +155,7 @@ export class ParserContextImplementation {
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'deepest') {
-            return parserInvariant(function (message) {
+            return customInvariant(function (message) {
                 let deepestDepth = 0;
                 let deepestChildErrors = [];
                 for (const childError of childErrors) {
@@ -178,7 +179,7 @@ export class ParserContextImplementation {
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'all') {
-            return parserInvariant(function (message) {
+            return customInvariant(function (message) {
                 message += [
                     '',
                     'Child error stacks, indented:',

package/build/parserContext.test.js

@@ -1,6 +1,6 @@
 import test from 'ava';
 import { ParserContextImplementation } from './parserContext.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { InputReaderImplementation } from './inputReader.js';
 import { ParserUnexpectedEndOfInputError } from './parserError.js';
 const commonParserContextArguments = [
@@ -11,7 +11,7 @@ const commonParserContextArguments = [
     },
 ];
 test('parserContext.read', async (t) => {
-    const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield '';
         yield 'abc';
         yield 'def';
@@ -26,7 +26,7 @@ test('parserContext.read', async (t) => {
     });
 });
 test('parserContext.lookahead', async (t) => {
-    const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })()), ...commonParserContextArguments);
     const lookaheadContext1 = parserContext.lookahead();
@@ -54,7 +54,7 @@ test('parserContext.lookahead', async (t) => {
     t.is(lookaheadContext3.position, 3);
 });
 test('parserContext.unlookahead', async (t) => {
-    const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })()), ...commonParserContextArguments);
     const lookaheadContext = parserContext.lookahead();
@@ -68,7 +68,7 @@ test('parserContext.unlookahead', async (t) => {
     t.is(await lookaheadContext.read(0), 'c');
 });
 test('parserContext.unlookahead while peeking', async (t) => {
-    const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })()), ...commonParserContextArguments);
     const lookaheadContext = parserContext.lookahead();
@@ -79,7 +79,7 @@ test('parserContext.unlookahead while peeking', async (t) => {
     t.is(await peekPromise, 'c');
 });
 test('parserContext deep unlookahead normal order', async (t) => {
-    const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })()), ...commonParserContextArguments);
     const child = parserContext.lookahead();
@@ -92,7 +92,7 @@ test('parserContext deep unlookahead normal order', async (t) => {
     t.is(await parserContext.read(0), 'd');
 });
 test('parserContext deep unlookahead weird order', async (t) => {
-    const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })()), ...commonParserContextArguments);
     const child = parserContext.lookahead({

package/build/parserCreatorCompose.d.ts

@@ -1,3 +1,3 @@
-import { Parser } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
-export declare function parserCreatorCompose<Arguments extends unknown[], OutputA, OutputB, Sequence, Element = DeriveSequenceElement<Sequence>>(f1: (...args: Arguments) => Parser<OutputA, Sequence, Element>, f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>): (...args: Arguments) => Parser<OutputB, Sequence, Element>;
+import { type Parser } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
+export declare function parserCreatorCompose<Arguments extends unknown[], OutputA, OutputB, Sequence, Element = DeriveSequenceElement<Sequence>>(f1: (...arguments_: Arguments) => Parser<OutputA, Sequence, Element>, f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>): (...arguments_: Arguments) => Parser<OutputB, Sequence, Element>;

package/build/parserCreatorCompose.js

@@ -1,6 +1,6 @@
 export function parserCreatorCompose(f1, f2) {
-    return (...args) => {
-        const parserA = f1(...args);
+    return (...arguments_) => {
+        const parserA = f1(...arguments_);
         return async (parserContext) => {
             const outputA = await parserA(parserContext);
             const parserB = f2(outputA);

package/build/parserImplementationInvariant.d.ts

@@ -1,2 +1,2 @@
-import { type Falsy, type ValueOrAccessor } from './parserInvariant.js';
+import { type Falsy, type ValueOrAccessor } from './customInvariant.js';
 export declare function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;

package/build/parserImplementationInvariant.js

@@ -1,5 +1,5 @@
 import { ParserImplementationInvariantError } from './parserError.js';
-import { parserInvariant } from './parserInvariant.js';
+import { customInvariant } from './customInvariant.js';
 export function parserImplementationInvariant(value, format, ...formatArguments) {
-    return parserInvariant(ParserImplementationInvariantError, value, format, ...formatArguments);
+    return customInvariant(ParserImplementationInvariantError, value, format, ...formatArguments);
 }

package/build/parserInputCompanion.d.ts

@@ -0,0 +1,20 @@
+export type ParserInputCompanion<Sequence, Element> = {
+    is(value: unknown): value is Sequence;
+    from(elements: Element[]): Sequence;
+    length(sequence: Sequence): number;
+    at(sequence: Sequence, index: number): Element | undefined;
+};
+export declare class StringParserInputCompanion implements ParserInputCompanion<string, string> {
+    is(value: unknown): value is string;
+    from(elements: string[]): string;
+    length(sequence: string): number;
+    at(sequence: string, index: number): string | undefined;
+}
+export declare const stringParserInputCompanion: StringParserInputCompanion;
+export declare class Uint8ArrayParserInputCompanion implements ParserInputCompanion<Uint8Array, number> {
+    is(value: unknown): value is Uint8Array;
+    from(elements: number[]): Uint8Array;
+    length(sequence: Uint8Array): number;
+    at(sequence: Uint8Array, index: number): number | undefined;
+}
+export declare const uint8ArrayParserInputCompanion: Uint8ArrayParserInputCompanion;

package/build/parserInputCompanion.js

@@ -0,0 +1,30 @@
+export class StringParserInputCompanion {
+    is(value) {
+        return typeof value === 'string';
+    }
+    from(elements) {
+        return elements.join('');
+    }
+    length(sequence) {
+        return sequence.length;
+    }
+    at(sequence, index) {
+        return sequence.at(index);
+    }
+}
+export const stringParserInputCompanion = new StringParserInputCompanion();
+export class Uint8ArrayParserInputCompanion {
+    is(value) {
+        return value instanceof Uint8Array;
+    }
+    from(elements) {
+        return new Uint8Array(elements);
+    }
+    length(sequence) {
+        return sequence.length;
+    }
+    at(sequence, index) {
+        return sequence.at(index);
+    }
+}
+export const uint8ArrayParserInputCompanion = new Uint8ArrayParserInputCompanion();

package/build/parserInvariant.d.ts

@@ -1,4 +1,4 @@
 import { type Constructor } from 'type-fest';
 export type Falsy = '' | 0 | false | undefined;
 export type ValueOrAccessor<T> = T | (() => T);
-export declare function parserInvariant<T>(ErrorConstructor: Constructor<Error, [message: string]> | ((message: string) => Error), value: T, formatOrFormatLines: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
+export declare function customInvariant<T>(ErrorConstructor: Constructor<Error, [message: string]> | ((message: string) => Error), value: T, formatOrFormatLines: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;

package/build/parserInvariant.js

@@ -1,4 +1,4 @@
-export function parserInvariant(ErrorConstructor, value, formatOrFormatLines, ...formatArguments) {
+export function customInvariant(ErrorConstructor, value, formatOrFormatLines, ...formatArguments) {
     if (value) {
         return value;
     }

package/build/quantifierParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createQuantifierParser: <Output, Sequence>(childParser: Parser<Output, Sequence>, count: number) => Parser<Output[], Sequence>;

package/build/quantifierParser.js

@@ -0,0 +1,17 @@
+import { getParserName, setParserName } from './parser.js';
+export const createQuantifierParser = (childParser, count) => {
+    const quantifierParser = async (parserContext) => {
+        const elements = [];
+        for (let index = 0; index < count; index++) {
+            elements.push(await childParser(parserContext));
+        }
+        return elements;
+    };
+    setParserName(quantifierParser, [
+        getParserName(childParser, 'anonymousQuantifierChild'),
+        '{',
+        count,
+        '}',
+    ].join(''));
+    return quantifierParser;
+};

package/build/sequenceBuffer.d.ts

@@ -1,14 +1,14 @@
-import { type InputCompanion } from './inputCompanion.js';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 export type SequenceBuffer<Sequence, Element> = {
     push(sequence: Sequence): void;
     peek(offset: number): Element | undefined;
     skip(offset: number): void;
 };
 export declare class SequenceBufferImplementation<Sequence, Element> implements SequenceBuffer<Sequence, Element> {
-    private readonly _inputCompanion;
+    private readonly _parserInputCompanion;
     private readonly _sequences;
     private _indexInFirstSequence;
-    constructor(_inputCompanion: InputCompanion<Sequence, Element>);
+    constructor(_parserInputCompanion: ParserInputCompanion<Sequence, Element>);
     push(sequence: Sequence): void;
     peek(offset: number): Element | undefined;
     skip(offset: number): void;

package/build/sequenceBuffer.js

@@ -1,16 +1,16 @@
 import invariant from 'invariant';
 export class SequenceBufferImplementation {
-    _inputCompanion;
+    _parserInputCompanion;
     _sequences = [];
     _indexInFirstSequence = 0;
-    constructor(_inputCompanion) {
-        this._inputCompanion = _inputCompanion;
+    constructor(_parserInputCompanion) {
+        this._parserInputCompanion = _parserInputCompanion;
     }
     push(sequence) {
         this._sequences.push(sequence);
         while (this._sequences.length > 0) {
             const firstSequence = this._sequences[0];
-            const firstSequenceLength = this._inputCompanion.length(firstSequence);
+            const firstSequenceLength = this._parserInputCompanion.length(firstSequence);
             if (firstSequenceLength === 0) {
                 this._sequences.shift();
                 continue;
@@ -26,9 +26,9 @@ export class SequenceBufferImplementation {
         invariant(offset >= 0, 'Offset must be non-negative.');
         let index = this._indexInFirstSequence + offset;
         for (const sequence of this._sequences) {
-            const sequenceLength = this._inputCompanion.length(sequence);
+            const sequenceLength = this._parserInputCompanion.length(sequence);
             if (index < sequenceLength) {
-                return this._inputCompanion.at(sequence, index);
+                return this._parserInputCompanion.at(sequence, index);
             }
             index -= sequenceLength;
         }

package/build/sequenceBuffer.test.js

@@ -1,8 +1,8 @@
 import test from 'ava';
 import { SequenceBufferImplementation } from './sequenceBuffer.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 test('sequenceBuffer', t => {
-    const sequenceBuffer = new SequenceBufferImplementation(stringInputCompanion);
+    const sequenceBuffer = new SequenceBufferImplementation(stringParserInputCompanion);
     t.is(sequenceBuffer.peek(0), undefined);
     sequenceBuffer.push('');
     t.is(sequenceBuffer.peek(0), undefined);

package/build/sequenceUnparser.d.ts

@@ -0,0 +1,2 @@
+import { Unparser } from "./unparser.js";
+export declare const createSequenceUnparser: <Sequence>() => Unparser<Sequence, Sequence>;

package/build/sequenceUnparser.js

@@ -0,0 +1,6 @@
+export const createSequenceUnparser = () => {
+    const sequenceUnparser = async function* (input) {
+        yield input;
+    };
+    return sequenceUnparser;
+};

package/build/sliceBoundedParser.d.ts

@@ -1,2 +1,2 @@
-import { Parser } from "./parser.js";
+import { type Parser } from './parser.js';
 export declare const createSliceBoundedParser: <Output, Sequence>(childParser: Parser<Output, Sequence>, sliceEnd: number) => Parser<Output, Sequence>;

package/build/sliceBoundedParser.js

@@ -1,4 +1,4 @@
-import { getParserName, setParserName } from "./parser.js";
+import { getParserName, setParserName } from './parser.js';
 export const createSliceBoundedParser = (childParser, sliceEnd) => {
     const sliceBoundedParser = async (parserContext) => {
         const childParserContext = parserContext.lookahead({

package/build/sliceBoundedParser.test.js

@@ -4,7 +4,7 @@ import { createElementParser } from './elementParser.js';
 import { createTupleParser } from './tupleParser.js';
 import { createSliceBoundedParser } from './sliceBoundedParser.js';
 import { runParser } from './parser.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 const anythingParser = createArrayParser(createElementParser());
 test('sliceBoundedParser', async (t) => {
     const parser = createTupleParser([
@@ -12,7 +12,7 @@ test('sliceBoundedParser', async (t) => {
         createSliceBoundedParser(anythingParser, 2),
         createElementParser(),
     ]);
-    const result = await runParser(parser, 'abba', stringInputCompanion);
+    const result = await runParser(parser, 'abba', stringParserInputCompanion);
     t.deepEqual(result, [
         'a',
         [

package/build/terminatedArrayParser.d.ts

@@ -1,2 +1,2 @@
-import { Parser } from "./parser.js";
+import { type Parser } from './parser.js';
 export declare const createTerminatedArrayParser: <ElementOutput, TerminatorOutput, Sequence>(elementParser: Parser<ElementOutput, Sequence>, terminatorParser: Parser<unknown, Sequence>) => Parser<[ElementOutput[], TerminatorOutput], Sequence>;

package/build/terminatedArrayParser.js

@@ -1,6 +1,6 @@
-import { getParserName, setParserName } from "./parser.js";
-import { promiseCompose } from "./promiseCompose.js";
-import { createUnionParser } from "./unionParser.js";
+import { getParserName, setParserName } from './parser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createUnionParser } from './unionParser.js';
 class Terminated {
     value;
     constructor(value) {

package/build/uint8Array.d.ts

@@ -0,0 +1 @@
+export declare function uint8ArrayAsyncIterableToUint8Array(uint8ArrayAsyncIterable: AsyncIterable<Uint8Array> | Iterable<Uint8Array>): Promise<Uint8Array>;

package/build/uint8Array.js

@@ -0,0 +1,7 @@
+export async function uint8ArrayAsyncIterableToUint8Array(uint8ArrayAsyncIterable) {
+    const chunks = [];
+    for await (const chunk of uint8ArrayAsyncIterable) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+}

package/build/unparser.d.ts

@@ -0,0 +1,8 @@
+import { DeriveSequenceElement } from "./sequence.js";
+import { UnparserContext, WriteEarlier, WriteLater } from "./unparserContext.js";
+import { UnparserOutputCompanion } from "./unparserOutputCompanion.js";
+type UnparserIterableValue<Sequence, Element> = Sequence | Element | WriteLater<Sequence, Element> | WriteEarlier<Sequence, Element>;
+export type UnparserResult<Sequence, Element> = AsyncIterable<UnparserIterableValue<Sequence, Element>>;
+export type Unparser<Input, Sequence, Element = DeriveSequenceElement<Sequence>> = (input: Input, unparserContext: UnparserContext<Sequence, Element>) => UnparserResult<Sequence, Element>;
+export declare function runUnparser<Input, Sequence, Element = DeriveSequenceElement<Sequence>>(unparser: Unparser<Input, Sequence, Element>, input: Input, unparserOutputCompanion: UnparserOutputCompanion<Sequence, Element>): AsyncIterable<Sequence>;
+export {};

package/build/unparser.js

@@ -0,0 +1,104 @@
+import invariant from "invariant";
+import { UnparserContextImplementation, WriteEarlier, WriteLater } from "./unparserContext.js";
+import { unparserImplementationInvariant } from "./unparserImplementationInvariant.js";
+async function* onYield(asyncIterable, onYield) {
+    for await (const value of asyncIterable) {
+        onYield(value);
+        yield value;
+    }
+}
+async function* elementsToSequences(values, unparserOutputCompanion) {
+    let elements = [];
+    for await (const value of values) {
+        if (value instanceof WriteLater
+            || value instanceof WriteEarlier) {
+            if (elements.length > 0) {
+                const sequence = unparserOutputCompanion.from(elements);
+                yield sequence;
+                elements = [];
+            }
+            yield value;
+        }
+        else if (unparserOutputCompanion.is(value)) {
+            if (unparserOutputCompanion.length(value) === 0) {
+                continue;
+            }
+            if (elements.length > 0) {
+                const sequence = unparserOutputCompanion.from(elements);
+                yield sequence;
+                elements = [];
+            }
+            yield value;
+        }
+        else {
+            elements.push(value);
+        }
+    }
+    if (elements.length > 0) {
+        const sequence = unparserOutputCompanion.from(elements);
+        yield sequence;
+    }
+}
+function wrapUnparserResult(unparserResult, unparserContext, unparserOutputCompanion) {
+    return onYield(elementsToSequences(unparserResult, unparserOutputCompanion), value => unparserContext.handleYield(value));
+}
+export async function* runUnparser(unparser, input, unparserOutputCompanion) {
+    const unparserContext = new UnparserContextImplementation(unparserOutputCompanion);
+    const values = unparser(input, unparserContext);
+    const valuesWithoutElements = wrapUnparserResult(values, unparserContext, unparserOutputCompanion);
+    const outputQueue = [];
+    const iteratorStack = [
+        [
+            valuesWithoutElements[Symbol.asyncIterator](),
+            value => outputQueue.push(value),
+            () => { },
+        ],
+    ];
+    while (true) {
+        while (outputQueue.length > 0
+            && !(outputQueue[0] instanceof WriteLater)) {
+            yield outputQueue.shift();
+        }
+        if (iteratorStack.length === 0) {
+            break;
+        }
+        const [iterator, pushOutput, finishOutput] = iteratorStack[0];
+        const iteratorResult = await iterator.next();
+        if (iteratorResult.done) {
+            finishOutput();
+            iteratorStack.shift();
+            continue;
+        }
+        const { value } = iteratorResult;
+        if (value instanceof WriteEarlier) {
+            const { writeLater, unparserResult, unparserContext } = value;
+            invariant(unparserContext instanceof UnparserContextImplementation, 'UnparserContext not an instance of UnparserContextImplementation.');
+            function getOutputQueueWriteLaterIndex() {
+                const outputQueueWriteLaterIndex = outputQueue.indexOf(writeLater);
+                unparserImplementationInvariant(outputQueueWriteLaterIndex !== -1, [
+                    'WriteLater has already been written or was not yielded yet.',
+                    'WriteLater stack: %s',
+                    'End of WriteLater stack.',
+                ], writeLater.stack);
+                return outputQueueWriteLaterIndex;
+            }
+            const unparserResultWithoutElements = wrapUnparserResult(unparserResult, unparserContext, unparserOutputCompanion);
+            const newPushOutput = value => {
+                const outputQueueWriteLaterIndex = getOutputQueueWriteLaterIndex();
+                outputQueue.splice(outputQueueWriteLaterIndex, 0, value);
+            };
+            const newFinishOutput = () => {
+                const outputQueueWriteLaterIndex = getOutputQueueWriteLaterIndex();
+                const [removedValue] = outputQueue.splice(outputQueueWriteLaterIndex, 1);
+                invariant(removedValue === writeLater, 'WriteLater was not removed from the output queue.');
+            };
+            iteratorStack.unshift([
+                unparserResultWithoutElements[Symbol.asyncIterator](),
+                newPushOutput,
+                newFinishOutput,
+            ]);
+            continue;
+        }
+        pushOutput(value);
+    }
+}

package/build/unparser.test.d.ts

@@ -0,0 +1 @@
+export {};