@react-native-harness/runtime 1.0.0-alpha.1 → 1.0.0-alpha.10

package/dist/rntl/expect.js

@@ -1,670 +0,0 @@
-// Symbol to identify asymmetric matchers
-const ASYMMETRIC_MATCHER = Symbol('asymmetric-matcher');
-// Asymmetric matcher implementations
-class AnythingMatcher {
-    [ASYMMETRIC_MATCHER] = true;
-    asymmetricMatch(other) {
-        return other !== null && other !== undefined;
-    }
-    toString() {
-        return 'Anything';
-    }
-}
-class AnyMatcher {
-    expectedType;
-    [ASYMMETRIC_MATCHER] = true;
-    constructor(expectedType) {
-        this.expectedType = expectedType;
-    }
-    asymmetricMatch(other) {
-        if (this.expectedType === String) {
-            return typeof other === 'string';
-        }
-        if (this.expectedType === Number) {
-            return typeof other === 'number';
-        }
-        if (this.expectedType === Boolean) {
-            return typeof other === 'boolean';
-        }
-        if (this.expectedType === Array) {
-            return Array.isArray(other);
-        }
-        if (this.expectedType === Object) {
-            return (typeof other === 'object' && other !== null && !Array.isArray(other));
-        }
-        return other instanceof this.expectedType;
-    }
-    toString() {
-        return `Any<${this.expectedType.name}>`;
-    }
-}
-class ArrayContainingMatcher {
-    expectedArray;
-    [ASYMMETRIC_MATCHER] = true;
-    constructor(expectedArray) {
-        this.expectedArray = expectedArray;
-    }
-    asymmetricMatch(other) {
-        if (!Array.isArray(other)) {
-            return false;
-        }
-        return this.expectedArray.every((expectedItem) => other.some((otherItem) => deepEqualWithAsymmetric(otherItem, expectedItem)));
-    }
-    toString() {
-        return `ArrayContaining [${this.expectedArray
-            .map((item) => JSON.stringify(item))
-            .join(', ')}]`;
-    }
-}
-class ObjectContainingMatcher {
-    expectedObject;
-    [ASYMMETRIC_MATCHER] = true;
-    constructor(expectedObject) {
-        this.expectedObject = expectedObject;
-    }
-    asymmetricMatch(other) {
-        if (other == null || typeof other !== 'object' || Array.isArray(other)) {
-            return false;
-        }
-        const otherObj = other;
-        return Object.entries(this.expectedObject).every(([key, expectedValue]) => key in otherObj && deepEqualWithAsymmetric(otherObj[key], expectedValue));
-    }
-    toString() {
-        return `ObjectContaining ${JSON.stringify(this.expectedObject)}`;
-    }
-}
-class StringContainingMatcher {
-    expectedString;
-    [ASYMMETRIC_MATCHER] = true;
-    constructor(expectedString) {
-        this.expectedString = expectedString;
-    }
-    asymmetricMatch(other) {
-        return typeof other === 'string' && other.includes(this.expectedString);
-    }
-    toString() {
-        return `StringContaining "${this.expectedString}"`;
-    }
-}
-class StringMatchingMatcher {
-    expectedPattern;
-    [ASYMMETRIC_MATCHER] = true;
-    constructor(expectedPattern) {
-        this.expectedPattern = expectedPattern;
-    }
-    asymmetricMatch(other) {
-        if (typeof other !== 'string') {
-            return false;
-        }
-        if (this.expectedPattern instanceof RegExp) {
-            return this.expectedPattern.test(other);
-        }
-        return other.includes(this.expectedPattern);
-    }
-    toString() {
-        return `StringMatching ${this.expectedPattern}`;
-    }
-}
-class ArrayOfMatcher {
-    expectedValue;
-    [ASYMMETRIC_MATCHER] = true;
-    constructor(expectedValue) {
-        this.expectedValue = expectedValue;
-    }
-    asymmetricMatch(other) {
-        if (!Array.isArray(other)) {
-            return false;
-        }
-        return other.every((item) => deepEqualWithAsymmetric(item, this.expectedValue));
-    }
-    toString() {
-        return `ArrayOf ${JSON.stringify(this.expectedValue)}`;
-    }
-}
-class CloseToMatcher {
-    expectedNumber;
-    numDigits;
-    [ASYMMETRIC_MATCHER] = true;
-    constructor(expectedNumber, numDigits = 2) {
-        this.expectedNumber = expectedNumber;
-        this.numDigits = numDigits;
-    }
-    asymmetricMatch(other) {
-        const otherNum = Number(other);
-        if (Number.isNaN(otherNum)) {
-            return false;
-        }
-        const diff = Math.abs(otherNum - this.expectedNumber);
-        const precision = Math.pow(10, -this.numDigits) / 2;
-        return diff < precision;
-    }
-    toString() {
-        return `CloseTo ${this.expectedNumber} (precision: ${this.numDigits} digits)`;
-    }
-}
-class NotMatcher {
-    innerMatcher;
-    [ASYMMETRIC_MATCHER] = true;
-    constructor(innerMatcher) {
-        this.innerMatcher = innerMatcher;
-    }
-    asymmetricMatch(other) {
-        return !this.innerMatcher.asymmetricMatch(other);
-    }
-    toString() {
-        return `Not ${this.innerMatcher.toString()}`;
-    }
-}
-const isAsymmetricMatcher = (obj) => {
-    return obj != null && typeof obj === 'object' && ASYMMETRIC_MATCHER in obj;
-};
-const deepEqualWithAsymmetric = (a, b) => {
-    // Handle asymmetric matchers
-    if (isAsymmetricMatcher(b)) {
-        return b.asymmetricMatch(a);
-    }
-    if (isAsymmetricMatcher(a)) {
-        return a.asymmetricMatch(b);
-    }
-    // Fall back to regular deep equal
-    return deepEqual(a, b);
-};
-class ExpectError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ExpectError';
-    }
-}
-const deepEqual = (a, b) => {
-    if (a === b)
-        return true;
-    if (a == null || b == null)
-        return a === b;
-    if (typeof a !== typeof b)
-        return false;
-    if (typeof a === 'object') {
-        const aArray = Array.isArray(a);
-        const bArray = Array.isArray(b);
-        if (aArray !== bArray)
-            return false;
-        if (aArray) {
-            const aArr = a;
-            const bArr = b;
-            if (aArr.length !== bArr.length)
-                return false;
-            return aArr.every((item, index) => deepEqualWithAsymmetric(item, bArr[index]));
-        }
-        const aObj = a;
-        const bObj = b;
-        const aKeys = Object.keys(aObj);
-        const bKeys = Object.keys(bObj);
-        if (aKeys.length !== bKeys.length)
-            return false;
-        return aKeys.every((key) => bKeys.includes(key) && deepEqualWithAsymmetric(aObj[key], bObj[key]));
-    }
-    return false;
-};
-const createMatchers = (actual, isNot = false) => {
-    const assertResult = (result) => {
-        const shouldPass = isNot ? !result.pass : result.pass;
-        if (!shouldPass) {
-            throw new ExpectError(result.message);
-        }
-    };
-    return {
-        toBe(expected) {
-            const pass = Object.is(actual, expected);
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be ${expected}`
-                    : `Expected ${actual} to be ${expected}`,
-            });
-        },
-        toEqual(expected) {
-            const pass = deepEqual(actual, expected);
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${JSON.stringify(actual)} not to equal ${JSON.stringify(expected)}`
-                    : `Expected ${JSON.stringify(actual)} to equal ${JSON.stringify(expected)}`,
-            });
-        },
-        toStrictEqual(expected) {
-            // For now, same as toEqual - can be enhanced later for strict checking
-            const pass = deepEqual(actual, expected);
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${JSON.stringify(actual)} not to strictly equal ${JSON.stringify(expected)}`
-                    : `Expected ${JSON.stringify(actual)} to strictly equal ${JSON.stringify(expected)}`,
-            });
-        },
-        toBeTruthy() {
-            const pass = Boolean(actual);
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be truthy`
-                    : `Expected ${actual} to be truthy`,
-            });
-        },
-        toBeFalsy() {
-            const pass = !actual;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be falsy`
-                    : `Expected ${actual} to be falsy`,
-            });
-        },
-        toBeNull() {
-            const pass = actual === null;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be null`
-                    : `Expected ${actual} to be null`,
-            });
-        },
-        toBeUndefined() {
-            const pass = actual === undefined;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be undefined`
-                    : `Expected ${actual} to be undefined`,
-            });
-        },
-        toBeDefined() {
-            const pass = actual !== undefined;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be defined`
-                    : `Expected ${actual} to be defined`,
-            });
-        },
-        toBeInstanceOf(expected) {
-            const pass = actual instanceof expected;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be instance of ${expected.name}`
-                    : `Expected ${actual} to be instance of ${expected.name}`,
-            });
-        },
-        toContain(expected) {
-            let pass = false;
-            if (typeof actual === 'string' && typeof expected === 'string') {
-                pass = actual.includes(expected);
-            }
-            else if (Array.isArray(actual)) {
-                pass = actual.includes(expected);
-            }
-            else if (actual && typeof actual === 'object') {
-                pass = Object.values(actual).includes(expected);
-            }
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${JSON.stringify(actual)} not to contain ${JSON.stringify(expected)}`
-                    : `Expected ${JSON.stringify(actual)} to contain ${JSON.stringify(expected)}`,
-            });
-        },
-        toContainEqual(expected) {
-            let pass = false;
-            if (Array.isArray(actual)) {
-                pass = actual.some((item) => deepEqual(item, expected));
-            }
-            else if (actual && typeof actual === 'object') {
-                pass = Object.values(actual).some((item) => deepEqual(item, expected));
-            }
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${JSON.stringify(actual)} not to contain equal ${JSON.stringify(expected)}`
-                    : `Expected ${JSON.stringify(actual)} to contain equal ${JSON.stringify(expected)}`,
-            });
-        },
-        toHaveLength(expected) {
-            const actualLength = actual?.length;
-            const pass = actualLength === expected;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${JSON.stringify(actual)} not to have length ${expected}`
-                    : `Expected ${JSON.stringify(actual)} to have length ${expected}, but got ${actualLength}`,
-            });
-        },
-        toHaveProperty(keyPath, value) {
-            const keys = Array.isArray(keyPath) ? keyPath : keyPath.split('.');
-            let current = actual;
-            let pass = true;
-            for (const key of keys) {
-                if (current == null ||
-                    typeof current !== 'object' ||
-                    !(key in current)) {
-                    pass = false;
-                    break;
-                }
-                current = current[key];
-            }
-            if (pass && value !== undefined) {
-                pass = deepEqual(current, value);
-            }
-            const keyStr = Array.isArray(keyPath) ? keyPath.join('.') : keyPath;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${JSON.stringify(actual)} not to have property "${keyStr}"${value !== undefined ? ` with value ${JSON.stringify(value)}` : ''}`
-                    : `Expected ${JSON.stringify(actual)} to have property "${keyStr}"${value !== undefined ? ` with value ${JSON.stringify(value)}` : ''}`,
-            });
-        },
-        toBeCloseTo(expected, numDigits = 2) {
-            const actualNum = Number(actual);
-            const diff = Math.abs(actualNum - expected);
-            const precision = Math.pow(10, -numDigits) / 2;
-            const pass = diff < precision;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actualNum} not to be close to ${expected} (precision: ${numDigits} digits)`
-                    : `Expected ${actualNum} to be close to ${expected} (precision: ${numDigits} digits)`,
-            });
-        },
-        toBeGreaterThan(expected) {
-            const pass = actual > expected;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be greater than ${expected}`
-                    : `Expected ${actual} to be greater than ${expected}`,
-            });
-        },
-        toBeGreaterThanOrEqual(expected) {
-            const pass = actual >= expected;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be greater than or equal to ${expected}`
-                    : `Expected ${actual} to be greater than or equal to ${expected}`,
-            });
-        },
-        toBeLessThan(expected) {
-            const pass = actual < expected;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be less than ${expected}`
-                    : `Expected ${actual} to be less than ${expected}`,
-            });
-        },
-        toBeLessThanOrEqual(expected) {
-            const pass = actual <= expected;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be less than or equal to ${expected}`
-                    : `Expected ${actual} to be less than or equal to ${expected}`,
-            });
-        },
-        toBeNaN() {
-            const pass = Number.isNaN(actual);
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${actual} not to be NaN`
-                    : `Expected ${actual} to be NaN`,
-            });
-        },
-        toMatch(expected) {
-            const actualStr = String(actual);
-            const pass = expected instanceof RegExp
-                ? expected.test(actualStr)
-                : actualStr.includes(expected);
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected "${actualStr}" not to match ${expected}`
-                    : `Expected "${actualStr}" to match ${expected}`,
-            });
-        },
-        toMatchObject(expected) {
-            const matchesObject = (actualObj, expectedObj) => {
-                if (actualObj == null || typeof actualObj !== 'object') {
-                    return false;
-                }
-                for (const [key, expectedValue] of Object.entries(expectedObj)) {
-                    const actualValue = actualObj[key];
-                    if (expectedValue &&
-                        typeof expectedValue === 'object' &&
-                        !Array.isArray(expectedValue)) {
-                        if (!matchesObject(actualValue, expectedValue)) {
-                            return false;
-                        }
-                    }
-                    else if (!deepEqual(actualValue, expectedValue)) {
-                        return false;
-                    }
-                }
-                return true;
-            };
-            const pass = matchesObject(actual, expected);
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected ${JSON.stringify(actual)} not to match object ${JSON.stringify(expected)}`
-                    : `Expected ${JSON.stringify(actual)} to match object ${JSON.stringify(expected)}`,
-            });
-        },
-        toThrow(expected) {
-            let pass = false;
-            let thrownError = null;
-            try {
-                if (typeof actual === 'function') {
-                    actual();
-                }
-            }
-            catch (error) {
-                thrownError = error;
-                pass = true;
-                if (expected) {
-                    if (typeof expected === 'string') {
-                        pass = thrownError.message.includes(expected);
-                    }
-                    else if (expected instanceof RegExp) {
-                        pass = expected.test(thrownError.message);
-                    }
-                    else if (expected instanceof Error) {
-                        pass = thrownError.message === expected.message;
-                    }
-                }
-            }
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected function not to throw${expected ? ` ${expected}` : ''}`
-                    : `Expected function to throw${expected ? ` ${expected}` : ''}${thrownError ? `, but got: ${thrownError.message}` : ''}`,
-            });
-        },
-        toHaveBeenCalled() {
-            const mockCalls = actual?.mock
-                ?.calls;
-            const pass = Array.isArray(mockCalls) && mockCalls.length > 0;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected spy not to have been called`
-                    : `Expected spy to have been called`,
-            });
-        },
-        toHaveBeenCalledTimes(expected) {
-            const mockCalls = actual?.mock
-                ?.calls;
-            const actualTimes = Array.isArray(mockCalls) ? mockCalls.length : 0;
-            const pass = actualTimes === expected;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected spy not to have been called ${expected} times`
-                    : `Expected spy to have been called ${expected} times, but was called ${actualTimes} times`,
-            });
-        },
-        toHaveBeenCalledWith(...expected) {
-            const mockCalls = actual?.mock
-                ?.calls;
-            const pass = Array.isArray(mockCalls) &&
-                mockCalls.some((call) => deepEqual(call, expected));
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected spy not to have been called with ${JSON.stringify(expected)}`
-                    : `Expected spy to have been called with ${JSON.stringify(expected)}`,
-            });
-        },
-        toHaveBeenLastCalledWith(...expected) {
-            const mockCalls = actual?.mock
-                ?.calls;
-            const lastCall = Array.isArray(mockCalls)
-                ? mockCalls[mockCalls.length - 1]
-                : undefined;
-            const pass = lastCall ? deepEqual(lastCall, expected) : false;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected spy not to have been last called with ${JSON.stringify(expected)}`
-                    : `Expected spy to have been last called with ${JSON.stringify(expected)}`,
-            });
-        },
-        toHaveBeenNthCalledWith(nthCall, ...expected) {
-            const mockCalls = actual?.mock
-                ?.calls;
-            const call = Array.isArray(mockCalls)
-                ? mockCalls[nthCall - 1]
-                : undefined;
-            const pass = call ? deepEqual(call, expected) : false;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected spy not to have been called the ${nthCall}${nthCall === 1
-                        ? 'st'
-                        : nthCall === 2
-                            ? 'nd'
-                            : nthCall === 3
-                                ? 'rd'
-                                : 'th'} time with ${JSON.stringify(expected)}`
-                    : `Expected spy to have been called the ${nthCall}${nthCall === 1
-                        ? 'st'
-                        : nthCall === 2
-                            ? 'nd'
-                            : nthCall === 3
-                                ? 'rd'
-                                : 'th'} time with ${JSON.stringify(expected)}`,
-            });
-        },
-        toHaveReturned() {
-            const mockResults = actual?.mock?.results;
-            const pass = Array.isArray(mockResults) &&
-                mockResults.some((result) => result.type === 'return');
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected spy not to have returned`
-                    : `Expected spy to have returned`,
-            });
-        },
-        toHaveReturnedTimes(expected) {
-            const mockResults = actual?.mock?.results;
-            const returnCount = Array.isArray(mockResults)
-                ? mockResults.filter((result) => result.type === 'return').length
-                : 0;
-            const pass = returnCount === expected;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected spy not to have returned ${expected} times`
-                    : `Expected spy to have returned ${expected} times, but returned ${returnCount} times`,
-            });
-        },
-        toHaveReturnedWith(expected) {
-            const mockResults = actual?.mock?.results;
-            const pass = Array.isArray(mockResults) &&
-                mockResults.some((result) => result.type === 'return' && deepEqual(result.value, expected));
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected spy not to have returned with ${JSON.stringify(expected)}`
-                    : `Expected spy to have returned with ${JSON.stringify(expected)}`,
-            });
-        },
-        toHaveLastReturnedWith(expected) {
-            const mockResults = actual?.mock?.results;
-            const lastReturn = Array.isArray(mockResults)
-                ? mockResults.filter((result) => result.type === 'return').pop()
-                : undefined;
-            const pass = lastReturn ? deepEqual(lastReturn.value, expected) : false;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected spy not to have last returned with ${JSON.stringify(expected)}`
-                    : `Expected spy to have last returned with ${JSON.stringify(expected)}`,
-            });
-        },
-        toHaveNthReturnedWith(nthCall, expected) {
-            const mockResults = actual?.mock?.results;
-            const returns = Array.isArray(mockResults)
-                ? mockResults.filter((result) => result.type === 'return')
-                : [];
-            const nthReturn = returns[nthCall - 1];
-            const pass = nthReturn ? deepEqual(nthReturn.value, expected) : false;
-            assertResult({
-                pass,
-                message: isNot
-                    ? `Expected spy not to have returned the ${nthCall}${nthCall === 1
-                        ? 'st'
-                        : nthCall === 2
-                            ? 'nd'
-                            : nthCall === 3
-                                ? 'rd'
-                                : 'th'} time with ${JSON.stringify(expected)}`
-                    : `Expected spy to have returned the ${nthCall}${nthCall === 1
-                        ? 'st'
-                        : nthCall === 2
-                            ? 'nd'
-                            : nthCall === 3
-                                ? 'rd'
-                                : 'th'} time with ${JSON.stringify(expected)}`,
-            });
-        },
-    };
-};
-// Asymmetric matcher factory functions
-export const asymmetricMatchers = {
-    anything: () => new AnythingMatcher(),
-    any: (expectedType) => new AnyMatcher(expectedType),
-    arrayContaining: (expectedArray) => new ArrayContainingMatcher(expectedArray),
-    objectContaining: (expectedObject) => new ObjectContainingMatcher(expectedObject),
-    stringContaining: (expectedString) => new StringContainingMatcher(expectedString),
-    stringMatching: (expectedPattern) => new StringMatchingMatcher(expectedPattern),
-    arrayOf: (expectedValue) => new ArrayOfMatcher(expectedValue),
-    closeTo: (expectedNumber, numDigits) => new CloseToMatcher(expectedNumber, numDigits),
-    not: {
-        arrayContaining: (expectedArray) => new NotMatcher(new ArrayContainingMatcher(expectedArray)),
-        objectContaining: (expectedObject) => new NotMatcher(new ObjectContainingMatcher(expectedObject)),
-        stringContaining: (expectedString) => new NotMatcher(new StringContainingMatcher(expectedString)),
-        stringMatching: (expectedPattern) => new NotMatcher(new StringMatchingMatcher(expectedPattern)),
-        arrayOf: (expectedValue) => new NotMatcher(new ArrayOfMatcher(expectedValue)),
-    },
-};
-const expectFn = (actual) => {
-    const matchers = createMatchers(actual);
-    const notMatchers = createMatchers(actual, true);
-    return {
-        ...matchers,
-        not: notMatchers,
-    };
-};
-export const expect = expectFn;
-// Add asymmetric matchers directly to expect function
-Object.assign(expect, asymmetricMatchers);

package/dist/rntl/fn.d.ts

@@ -1,2 +0,0 @@
-export { fake } from 'sinon';
-//# sourceMappingURL=fn.d.ts.map

package/dist/rntl/fn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fn.d.ts","sourceRoot":"","sources":["../../src/rntl/fn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,OAAO,CAAC"}

package/dist/rntl/fn.js

@@ -1 +0,0 @@
-export { fake } from 'sinon';

package/dist/rntl/mock.d.ts

@@ -1,2 +0,0 @@
-export { mock, requireActual, clearMocks } from '../mock.js';
-//# sourceMappingURL=mock.d.ts.map

package/dist/rntl/mock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../src/rntl/mock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/rntl/mock.js

@@ -1 +0,0 @@
-export { mock, requireActual, clearMocks } from '../mock.js';

package/dist/rntl/render.d.ts

@@ -1,4 +0,0 @@
-import { ReactNode } from 'react';
-export declare const render: (node: ReactNode, options?: unknown) => Promise<void>;
-export declare const cleanup: () => Promise<void>;
-//# sourceMappingURL=render.d.ts.map

package/dist/rntl/render.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/rntl/render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIlC,eAAO,MAAM,MAAM,GACjB,MAAM,SAAS,EACf,UAAU,OAAO,KAChB,OAAO,CAAC,IAAI,CAId,CAAC;AAEF,eAAO,MAAM,OAAO,QAAa,OAAO,CAAC,IAAI,CAG5C,CAAC"}