@futpib/parser 1.0.1 → 1.0.3

package/build/smaliParser.test.d.ts

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

package/build/smaliParser.test.js

@@ -0,0 +1,410 @@
+import test from 'ava';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { getParserName, runParser } from './parser.js';
+import { fetchCid } from './fetchCid.js';
+import { smaliAnnotationParser, smaliCodeOperationParser, smaliCodeParameterParser, smaliCommentParser, smaliFieldParser, smaliMethodParser, smaliParser, } from './smaliParser.js';
+import { hasExecutable } from './hasExecutable.js';
+import { baksmaliClass } from './backsmali.js';
+const hasBaksmaliPromise = hasExecutable('baksmali');
+const stringParserTestSnapshot = Symbol('stringParserTestSnapshot');
+const stringParserTestIgnore = Symbol('stringParserTestIgnore');
+function stringParserTest(parser, examples) {
+    const parserName = getParserName(parser);
+    for (const [input, expected] of examples) {
+        test(parserName + ' ' + JSON.stringify(input), async (t) => {
+            const actual = await runParser(parser, input, stringParserInputCompanion, {
+                errorJoinMode: 'all',
+            });
+            if (expected === stringParserTestIgnore) {
+                t.pass('skipping test because expected is stringParserTestIgnore');
+            }
+            else if (expected === stringParserTestSnapshot) {
+                t.snapshot(actual);
+            }
+            else {
+                t.deepEqual(actual, expected);
+            }
+        });
+    }
+}
+stringParserTest(smaliCommentParser, [
+    [
+        '# this is a comment \n',
+        ' this is a comment ',
+    ],
+]);
+stringParserTest(smaliCodeParameterParser, [
+    [
+        '    .param p1\n',
+        {
+            register: {
+                index: 1,
+                prefix: 'p',
+            },
+            name: undefined,
+            annotation: undefined,
+        },
+    ],
+    [
+        '    .param p1, "savedInstanceState"    # Landroid/os/Bundle;\n',
+        {
+            register: {
+                index: 1,
+                prefix: 'p',
+            },
+            name: 'savedInstanceState',
+            annotation: undefined,
+        },
+    ],
+    [
+        `    .param p1    # Ljava/lang/ClassLoader;
+        .annotation build Landroid/annotation/NonNull;
+        .end annotation
+    .end param\n`,
+        {
+            register: {
+                index: 1,
+                prefix: 'p',
+            },
+            name: undefined,
+            annotation: {
+                visibility: 'build',
+                type: 'Landroid/annotation/NonNull;',
+                elements: [],
+            },
+        },
+    ],
+]);
+stringParserTest(smaliFieldParser, [
+    [
+        '.field private barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;\n',
+        {
+            field: {
+                accessFlags: {
+                    abstract: false,
+                    annotation: false,
+                    bridge: false,
+                    constructor: false,
+                    declaredSynchronized: false,
+                    enum: false,
+                    final: false,
+                    interface: false,
+                    native: false,
+                    private: true,
+                    protected: false,
+                    public: false,
+                    static: false,
+                    strict: false,
+                    synchronized: false,
+                    synthetic: false,
+                    transient: false,
+                    varargs: false,
+                    volatile: false,
+                },
+                field: {
+                    class: 'FILLED_LATER',
+                    name: 'barcodeScannerView',
+                    type: 'Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;',
+                },
+            },
+            annotations: [],
+        },
+    ],
+    [
+        `.field public final g:Lo/b;
+    .annotation system Ldalvik/annotation/Signature;
+        value = {
+            "Lo/b<",
+            "Ljava/lang/Float;",
+            "Lo/i;",
+            ">;"
+        }
+    .end annotation
+.end field
+`,
+        {
+            field: {
+                accessFlags: {
+                    abstract: false,
+                    annotation: false,
+                    bridge: false,
+                    constructor: false,
+                    declaredSynchronized: false,
+                    enum: false,
+                    final: true,
+                    interface: false,
+                    native: false,
+                    private: false,
+                    protected: false,
+                    public: true,
+                    static: false,
+                    strict: false,
+                    synchronized: false,
+                    synthetic: false,
+                    transient: false,
+                    varargs: false,
+                    volatile: false,
+                },
+                field: {
+                    class: 'FILLED_LATER',
+                    name: 'g',
+                    type: 'Lo/b;',
+                },
+            },
+            annotations: [
+                {
+                    visibility: 'system',
+                    type: 'Ldalvik/annotation/Signature;',
+                    elements: [
+                        {
+                            name: 'value',
+                            value: {
+                                kind: 'string',
+                                value: [
+                                    'Lo/b<',
+                                    'Ljava/lang/Float;',
+                                    'Lo/i;',
+                                    '>;',
+                                ],
+                            },
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+]);
+stringParserTest(smaliAnnotationParser, [
+    [
+        `    .annotation system Ldalvik/annotation/Signature;
+                value = {
+                    "<T:",
+                    "Landroid/view/View;",
+                    ">(I)TT;"
+                }
+            .end annotation
+`,
+        {
+            visibility: 'system',
+            type: 'Ldalvik/annotation/Signature;',
+            elements: [
+                {
+                    name: 'value',
+                    value: {
+                        kind: 'string',
+                        value: [
+                            '<T:',
+                            'Landroid/view/View;',
+                            '>(I)TT;',
+                        ],
+                    },
+                },
+            ],
+        },
+    ],
+    [
+        `        .annotation build Landroid/annotation/NonNull;
+        .end annotation
+`,
+        {
+            visibility: 'build',
+            type: 'Landroid/annotation/NonNull;',
+            elements: [],
+        },
+    ],
+    [
+        `    .annotation system Ldalvik/annotation/Signature;
+        value = {
+            "Lo/b<",
+            "Ljava/lang/Float;",
+            "Lo/i;",
+            ">;"
+        }
+    .end annotation
+`,
+        {
+            visibility: 'system',
+            type: 'Ldalvik/annotation/Signature;',
+            elements: [
+                {
+                    name: 'value',
+                    value: {
+                        kind: 'string',
+                        value: [
+                            'Lo/b<',
+                            'Ljava/lang/Float;',
+                            'Lo/i;',
+                            '>;',
+                        ],
+                    },
+                },
+            ],
+        },
+    ],
+]);
+stringParserTest(smaliMethodParser, [
+    [
+        `.method public native synthetic instantiateActivity(Ljava/lang/ClassLoader;Ljava/lang/String;Landroid/content/Intent;)Landroid/app/Activity;
+    .param p1    # Ljava/lang/ClassLoader;
+        .annotation build Landroid/annotation/NonNull;
+        .end annotation
+    .end param
+.end method
+`,
+        stringParserTestSnapshot,
+    ],
+    [
+        `.method public native synthetic instantiateActivity(Ljava/lang/ClassLoader;Ljava/lang/String;Landroid/content/Intent;)Landroid/app/Activity;
+    .param p1    # Ljava/lang/ClassLoader;
+        .annotation build Landroid/annotation/NonNull;
+        .end annotation
+    .end param
+    .param p2    # Ljava/lang/String;
+        .annotation build Landroid/annotation/NonNull;
+        .end annotation
+    .end param
+    .annotation build Landroid/annotation/NonNull;
+    .end annotation
+
+    .annotation system Ldalvik/annotation/Throws;
+        value = {
+            Ljava/lang/ClassNotFoundException;,
+            Ljava/lang/IllegalAccessException;,
+            Ljava/lang/InstantiationException;
+        }
+    .end annotation
+.end method
+`,
+        stringParserTestSnapshot,
+    ],
+]);
+stringParserTest(smaliCodeOperationParser, [
+    [
+        `    invoke-static {}, Le4/k;->c()Le4/k;
+`,
+        {
+            operation: 'invoke-static',
+            registers: [],
+            method: {
+                class: 'Le4/k;',
+                name: 'c',
+                prototype: {
+                    parameters: [],
+                    returnType: 'Le4/k;',
+                    shorty: 'L',
+                },
+            },
+        },
+    ],
+    [
+        `    .packed-switch 0x0
+        :pswitch_5
+    .end packed-switch
+`,
+        stringParserTestSnapshot,
+    ],
+]);
+stringParserTest(smaliCodeOperationParser, [
+    [
+        `    .sparse-switch
+        -0x7073f927 -> :sswitch_47
+        -0x3465cce -> :sswitch_3e
+        0x388694fe -> :sswitch_33
+        0x3cbf870b -> :sswitch_28
+    .end sparse-switch
+`,
+        stringParserTestSnapshot,
+    ],
+]);
+stringParserTest(smaliCodeOperationParser, [
+    [
+        `    .array-data 4
+        0x10100a7
+        0x101009e
+    .end array-data
+`,
+        stringParserTestSnapshot,
+    ],
+]);
+stringParserTest(smaliMethodParser, [
+    [
+        `.method public final a()Landroid/os/Bundle;
+    .registers 2
+
+    iget v0, p0, Landroidx/lifecycle/b0;->a:I
+
+    packed-switch v0, :pswitch_data_c
+
+    :pswitch_5
+    iget-object v0, p0, Landroidx/lifecycle/b0;->b:Landroidx/lifecycle/c0;
+
+    invoke-static {v0}, Landroidx/lifecycle/c0;->a(Landroidx/lifecycle/c0;)Landroid/os/Bundle;
+
+    move-result-object v0
+
+    return-object v0
+
+    :pswitch_data_c
+    .packed-switch 0x0
+        :pswitch_5
+    .end packed-switch
+.end method
+`,
+        stringParserTestSnapshot,
+    ],
+]);
+const smaliFromDexMacro = test.macro({
+    title: (providedTitle, dexCid, smaliFilePath) => providedTitle ?? `smali from dex ${dexCid} ${smaliFilePath}`,
+    async exec(t, dexCid, smaliFilePath, shouldSnapshot) {
+        const hasBaksmali = await hasBaksmaliPromise;
+        if (!hasBaksmali) {
+            t.pass('skipping test because baksmali is not available');
+            return;
+        }
+        const dexStream = await fetchCid(dexCid);
+        const smali = await baksmaliClass(dexStream, smaliFilePath);
+        const actual = await runParser(smaliParser, smali, stringParserInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        // Console.dir(actual, { depth: null });
+        if (shouldSnapshot) {
+            t.snapshot(actual);
+        }
+        else {
+            // Console.dir(actual, { depth: null });
+            t.pass();
+        }
+    },
+});
+test.serial(smaliFromDexMacro, 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', 'pl/czak/minimal/MainActivity', true);
+test.serial(smaliFromDexMacro, 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', 'd/m', true);
+test.serial(smaliFromDexMacro, 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', 'com/journeyapps/barcodescanner/CaptureActivity', true);
+test.serial.skip(smaliFromDexMacro, 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', '', false);
+// Minimal failing test case reproducing the a0/n parsing issue
+test('parse smali with virtual method after direct methods (a0/n issue)', async (t) => {
+    const smali = `.class public final La0/n;
+.super Landroid/view/View;
+.source "SourceFile"
+
+# direct methods
+.method public static constructor <clinit>()V
+    .registers 1
+
+    return-void
+.end method
+
+# virtual methods
+.method public final b(Lr/o;ZJIJFLa0/a;)V
+    .registers 21
+
+    invoke-virtual/range {v0 .. v6}, La0/n;->e(JIJF)V
+
+    return-void
+.end method
+`;
+    const actual = await runParser(smaliParser, smali, stringParserInputCompanion, {
+        errorJoinMode: 'all',
+    });
+    t.truthy(actual);
+    t.is(actual.classData?.virtualMethods.length, 1);
+});

package/build/stringFromAsyncIterable.d.ts

@@ -0,0 +1 @@
+export declare function stringFromAsyncIterable(asyncIterable: AsyncIterable<string>): Promise<string>;

package/build/stringFromAsyncIterable.js

@@ -0,0 +1,7 @@
+export async function stringFromAsyncIterable(asyncIterable) {
+    let string = '';
+    for await (const chunk of asyncIterable) {
+        string += chunk;
+    }
+    return string;
+}

package/build/terminatedArrayParser.d.ts

@@ -1,2 +1,4 @@
 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>;
+export declare const createTerminatedArrayParserNaive: <ElementOutput, TerminatorOutput, Sequence>(elementParser: Parser<ElementOutput, Sequence>, terminatorParser: Parser<TerminatorOutput, Sequence>) => Parser<[ElementOutput[], TerminatorOutput], Sequence>;
+export declare const createTerminatedArrayParser: <ElementOutput, TerminatorOutput, Sequence>(elementParser: Parser<ElementOutput, Sequence>, terminatorParser: Parser<TerminatorOutput, Sequence>) => Parser<[ElementOutput[], TerminatorOutput], Sequence>;
+export declare const createTerminatedArrayParserUnsafe: <ElementOutput, TerminatorOutput, Sequence>(elementParser: Parser<ElementOutput, Sequence>, terminatorParser: Parser<TerminatorOutput, Sequence>) => Parser<[ElementOutput[], TerminatorOutput], Sequence>;

package/build/terminatedArrayParser.js

@@ -1,4 +1,6 @@
 import { getParserName, setParserName } from './parser.js';
+import { isParserParsingFailedError } from './parserError.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createUnionParser } from './unionParser.js';
 class Terminated {
@@ -7,14 +9,14 @@ class Terminated {
         this.value = value;
     }
 }
-export const createTerminatedArrayParser = (elementParser, terminatorParser) => {
+export const createTerminatedArrayParserNaive = (elementParser, terminatorParser) => {
     const wrappedTerminatorParser = promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue));
     setParserName(wrappedTerminatorParser, getParserName(terminatorParser, 'anonymousTerminator'));
     const elementOrTerminatorParser = createUnionParser([
         elementParser,
         promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue)),
     ]);
-    return async (parserContext) => {
+    const terminatedArrayParserNaive = async (parserContext) => {
         const elements = [];
         while (true) {
             const elementOrTerminator = await elementOrTerminatorParser(parserContext);
@@ -24,4 +26,79 @@ export const createTerminatedArrayParser = (elementParser, terminatorParser) =>
             elements.push(elementOrTerminator);
         }
     };
+    setParserName(terminatedArrayParserNaive, `${getParserName(elementParser, 'anonymousElement')}*?${getParserName(terminatorParser, 'anonymousTerminator')}`);
+    return terminatedArrayParserNaive;
+};
+export const createTerminatedArrayParser = (elementParser, terminatorParser) => {
+    const terminatedArrayParser = async (parserContext) => {
+        const elements = [];
+        while (true) {
+            const terminatorParserContext = parserContext.lookahead({
+                debugName: getParserName(terminatorParser, 'anonymousTerminator'),
+            });
+            try {
+                const terminatorValue = await terminatorParser(terminatorParserContext);
+                const elementParserContext = parserContext.lookahead({
+                    debugName: getParserName(elementParser, 'anonymousElement'),
+                });
+                try {
+                    await elementParser(elementParserContext);
+                    parserImplementationInvariant(false, [
+                        'Both element and terminator parsers matched.',
+                        'Element parser: %s',
+                        'Terminator parser: %s',
+                    ], getParserName(elementParser, 'anonymousElement'), getParserName(terminatorParser, 'anonymousTerminator'));
+                }
+                catch (error) {
+                    if (!(isParserParsingFailedError(error))) {
+                        throw error;
+                    }
+                }
+                finally {
+                    elementParserContext.dispose();
+                }
+                terminatorParserContext.unlookahead();
+                return [elements, terminatorValue];
+            }
+            catch (error) {
+                if (!(isParserParsingFailedError(error))) {
+                    throw error;
+                }
+            }
+            finally {
+                terminatorParserContext.dispose();
+            }
+            const element = await elementParser(parserContext);
+            elements.push(element);
+        }
+    };
+    setParserName(terminatedArrayParser, `${getParserName(elementParser, 'anonymousElement')}*?${getParserName(terminatorParser, 'anonymousTerminator')}`);
+    return terminatedArrayParser;
+};
+export const createTerminatedArrayParserUnsafe = (elementParser, terminatorParser) => {
+    const terminatedArrayParserUnsafe = async (parserContext) => {
+        const elements = [];
+        while (true) {
+            const terminatorParserContext = parserContext.lookahead({
+                debugName: getParserName(terminatorParser, 'anonymousTerminator'),
+            });
+            try {
+                const terminatorValue = await terminatorParser(terminatorParserContext);
+                terminatorParserContext.unlookahead();
+                return [elements, terminatorValue];
+            }
+            catch (error) {
+                if (!(isParserParsingFailedError(error))) {
+                    throw error;
+                }
+            }
+            finally {
+                terminatorParserContext.dispose();
+            }
+            const element = await elementParser(parserContext);
+            elements.push(element);
+        }
+    };
+    setParserName(terminatedArrayParserUnsafe, `${getParserName(elementParser, 'anonymousElement')}*?${getParserName(terminatorParser, 'anonymousTerminator')}`);
+    return terminatedArrayParserUnsafe;
 };

package/build/terminatedArrayParser.test.d.ts

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

package/build/terminatedArrayParser.test.js

@@ -0,0 +1,131 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { createTerminatedArrayParser, createTerminatedArrayParserNaive, createTerminatedArrayParserUnsafe } from './terminatedArrayParser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { HighResolutionTotalTimer } from './highResolutionTimer.js';
+import { createElementParser } from './elementParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createTupleParser } from './tupleParser.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createUnionParser } from './unionParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+test('terminatedArrayParser of union parsers', async (t) => {
+    const parser = createTerminatedArrayParser(createUnionParser([
+        createExactElementParser(1),
+        createExactElementParser(2),
+    ]), createExactElementParser(0));
+    const input = new Uint8Array([0]);
+    const result = await runParser(parser, input, uint8ArrayParserInputCompanion);
+    t.deepEqual(result, [[], 0]);
+});
+testProp('terminatedArrayParser both terminator and element matching', [
+    fc.string(),
+], async (t, string) => {
+    const terminatedArrayParserNaive = createTerminatedArrayParserNaive(createExactSequenceParser(string), createExactSequenceParser(string));
+    const terminatedArrayParser = createTerminatedArrayParser(createExactSequenceParser(string), createExactSequenceParser(string));
+    const [naiveResult, result,] = await Promise.allSettled([
+        runParser(terminatedArrayParserNaive, string, stringParserInputCompanion),
+        runParser(terminatedArrayParser, string, stringParserInputCompanion),
+    ]);
+    t.is(naiveResult.status, 'rejected');
+    if (result.status === 'rejected'
+        && naiveResult.status === 'rejected') {
+        result.reason.message = 'REDACTED';
+        naiveResult.reason.message = 'REDACTED';
+    }
+    t.deepEqual(result, naiveResult);
+}, {
+    verbose: true,
+});
+const naiveTotalTimer = new HighResolutionTotalTimer();
+const optimizedTotalTimer = new HighResolutionTotalTimer();
+const unsafeTotalTimer = new HighResolutionTotalTimer();
+testProp.serial('terminatedArrayParser', [
+    fc
+        .integer({
+        min: 1,
+        max: 2 ** 8,
+    })
+        .chain(terminatorLength => (fc
+        .string({
+        minLength: terminatorLength,
+    })
+        .map(string => ({
+        string,
+        terminator: string.slice(0 - terminatorLength),
+    }))
+        .filter(({ string, terminator }) => string.split(terminator).length === 2))),
+], async (t, { string, terminator }) => {
+    const terminatedArrayParserNaive = createTerminatedArrayParserNaive(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+        createElementParser(),
+    ]), ([_, element]) => element), createExactSequenceParser(terminator));
+    const terminatedArrayParser = createTerminatedArrayParser(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+        createElementParser(),
+    ]), ([_, element]) => element), createExactSequenceParser(terminator));
+    const createTestWrapperParser = (innerParser) => async (parserContext) => {
+        const [characters, terminator] = await innerParser(parserContext);
+        return {
+            string: characters.join(''),
+            terminator,
+            nextPeek: await parserContext.peek(0),
+            position: parserContext.position,
+        };
+    };
+    const actualNaive = await naiveTotalTimer.measureAsync(async () => runParser(createTestWrapperParser(terminatedArrayParserNaive), string, stringParserInputCompanion));
+    t.is(actualNaive.string.length + actualNaive.terminator.length, string.length);
+    const actual = await optimizedTotalTimer.measureAsync(async () => runParser(createTestWrapperParser(terminatedArrayParser), string, stringParserInputCompanion));
+    t.deepEqual(actual, actualNaive);
+}, {
+    verbose: true,
+});
+test.serial('terminatedArrayParser performance', t => {
+    t.true(optimizedTotalTimer.time * 1n < naiveTotalTimer.time, `Naive: ${naiveTotalTimer.time / 1000000n}ms, Optimized: ${optimizedTotalTimer.time / 1000000n}ms`);
+});
+testProp.serial('terminatedArrayParserUnsafe', [
+    fc
+        .integer({
+        min: 1,
+        max: 2 ** 8,
+    })
+        .chain(terminatorLength => (fc
+        .string({
+        minLength: terminatorLength,
+    })
+        .map(string => ({
+        string,
+        terminator: string.slice(0 - terminatorLength),
+    }))
+        .filter(({ string, terminator }) => string.split(terminator).length === 2))),
+], async (t, { string, terminator }) => {
+    const terminatedArrayParserNaive = createTerminatedArrayParserNaive(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+        createElementParser(),
+    ]), ([_, element]) => element), createExactSequenceParser(terminator));
+    const terminatedArrayParserUnsafe = createTerminatedArrayParserUnsafe(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+        createElementParser(),
+    ]), ([_, element]) => element), createExactSequenceParser(terminator));
+    const createTestWrapperParser = (innerParser) => async (parserContext) => {
+        const [characters, terminator] = await innerParser(parserContext);
+        return {
+            string: characters.join(''),
+            terminator,
+            nextPeek: await parserContext.peek(0),
+            position: parserContext.position,
+        };
+    };
+    const actualNaive = await runParser(createTestWrapperParser(terminatedArrayParserNaive), string, stringParserInputCompanion);
+    t.is(actualNaive.string.length + actualNaive.terminator.length, string.length);
+    const actual = await unsafeTotalTimer.measureAsync(async () => runParser(createTestWrapperParser(terminatedArrayParserUnsafe), string, stringParserInputCompanion));
+    t.deepEqual(actual, actualNaive);
+}, {
+    verbose: true,
+});
+test.serial('terminatedArrayParserUnsafe performance', t => {
+    t.true(unsafeTotalTimer.time * 1n < naiveTotalTimer.time, `Naive: ${naiveTotalTimer.time / 1000000n}ms, Unsafe: ${unsafeTotalTimer.time / 1000000n}ms`);
+});

package/build/toAsyncIterable.d.ts

@@ -0,0 +1 @@
+export declare function toAsyncIterable<T>(value: AsyncIterator<T>): AsyncIterable<T>;

package/build/toAsyncIterable.js

@@ -0,0 +1,7 @@
+export function toAsyncIterable(value) {
+    return {
+        [Symbol.asyncIterator]() {
+            return value;
+        },
+    };
+}

package/build/toAsyncIterator.d.ts

@@ -0,0 +1 @@
+export declare function toAsyncIterator<T>(value: AsyncIterator<T> | AsyncIterable<T> | Iterable<T> | T): AsyncIterator<T>;