@trpc/server 11.1.2 → 11.1.3-alpha-tmp-tsdown.23

package/dist/unstable-core-do-not-import/transformer.js

@@ -1,106 +1,96 @@
-'use strict';
-
-var utils = require('./utils.js');
+const require__Users_julius_dev_trpc_packages_server_src_unstable_core_do_not_import_utils = require('./utils.js');
 
+//#region src/unstable-core-do-not-import/transformer.ts
 /**
- * @internal
- */ function getDataTransformer(transformer) {
-    if ('input' in transformer) {
-        return transformer;
-    }
-    return {
-        input: transformer,
-        output: transformer
-    };
+* @internal
+*/
+function getDataTransformer(transformer) {
+	if ("input" in transformer) return transformer;
+	return {
+		input: transformer,
+		output: transformer
+	};
 }
 /**
- * @internal
- */ const defaultTransformer = {
-    input: {
-        serialize: (obj)=>obj,
-        deserialize: (obj)=>obj
-    },
-    output: {
-        serialize: (obj)=>obj,
-        deserialize: (obj)=>obj
-    }
+* @internal
+*/
+const defaultTransformer = {
+	input: {
+		serialize: (obj) => obj,
+		deserialize: (obj) => obj
+	},
+	output: {
+		serialize: (obj) => obj,
+		deserialize: (obj) => obj
+	}
 };
 function transformTRPCResponseItem(config, item) {
-    if ('error' in item) {
-        return {
-            ...item,
-            error: config.transformer.output.serialize(item.error)
-        };
-    }
-    if ('data' in item.result) {
-        return {
-            ...item,
-            result: {
-                ...item.result,
-                data: config.transformer.output.serialize(item.result.data)
-            }
-        };
-    }
-    return item;
+	if ("error" in item) return {
+		...item,
+		error: config.transformer.output.serialize(item.error)
+	};
+	if ("data" in item.result) return {
+		...item,
+		result: {
+			...item.result,
+			data: config.transformer.output.serialize(item.result.data)
+		}
+	};
+	return item;
 }
 /**
- * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
- **/ function transformTRPCResponse(config, itemOrItems) {
-    return Array.isArray(itemOrItems) ? itemOrItems.map((item)=>transformTRPCResponseItem(config, item)) : transformTRPCResponseItem(config, itemOrItems);
-}
-// FIXME:
-// - the generics here are probably unnecessary
-// - the RPC-spec could probably be simplified to combine HTTP + WS
-/** @internal */ function transformResultInner(response, transformer) {
-    if ('error' in response) {
-        const error = transformer.deserialize(response.error);
-        return {
-            ok: false,
-            error: {
-                ...response,
-                error
-            }
-        };
-    }
-    const result = {
-        ...response.result,
-        ...(!response.result.type || response.result.type === 'data') && {
-            type: 'data',
-            data: transformer.deserialize(response.result.data)
-        }
-    };
-    return {
-        ok: true,
-        result
-    };
+* Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
+**/
+function transformTRPCResponse(config, itemOrItems) {
+	return Array.isArray(itemOrItems) ? itemOrItems.map((item) => transformTRPCResponseItem(config, item)) : transformTRPCResponseItem(config, itemOrItems);
 }
-class TransformResultError extends Error {
-    constructor(){
-        super('Unable to transform response from server');
-    }
+/** @internal */
+function transformResultInner(response, transformer) {
+	if ("error" in response) {
+		const error = transformer.deserialize(response.error);
+		return {
+			ok: false,
+			error: {
+				...response,
+				error
+			}
+		};
+	}
+	const result = {
+		...response.result,
+		...(!response.result.type || response.result.type === "data") && {
+			type: "data",
+			data: transformer.deserialize(response.result.data)
+		}
+	};
+	return {
+		ok: true,
+		result
+	};
 }
+var TransformResultError = class extends Error {
+	constructor() {
+		super("Unable to transform response from server");
+	}
+};
 /**
- * Transforms and validates that the result is a valid TRPCResponse
- * @internal
- */ function transformResult(response, transformer) {
-    let result;
-    try {
-        // Use the data transformers on the JSON-response
-        result = transformResultInner(response, transformer);
-    } catch  {
-        throw new TransformResultError();
-    }
-    // check that output of the transformers is a valid TRPCResponse
-    if (!result.ok && (!utils.isObject(result.error.error) || typeof result.error.error['code'] !== 'number')) {
-        throw new TransformResultError();
-    }
-    if (result.ok && !utils.isObject(result.result)) {
-        throw new TransformResultError();
-    }
-    return result;
+* Transforms and validates that the result is a valid TRPCResponse
+* @internal
+*/
+function transformResult(response, transformer) {
+	let result;
+	try {
+		result = transformResultInner(response, transformer);
+	} catch {
+		throw new TransformResultError();
+	}
+	if (!result.ok && (!require__Users_julius_dev_trpc_packages_server_src_unstable_core_do_not_import_utils.isObject(result.error.error) || typeof result.error.error["code"] !== "number")) throw new TransformResultError();
+	if (result.ok && !require__Users_julius_dev_trpc_packages_server_src_unstable_core_do_not_import_utils.isObject(result.result)) throw new TransformResultError();
+	return result;
 }
 
+//#endregion
 exports.defaultTransformer = defaultTransformer;
 exports.getDataTransformer = getDataTransformer;
 exports.transformResult = transformResult;
-exports.transformTRPCResponse = transformTRPCResponse;
+exports.transformTRPCResponse = transformTRPCResponse;

package/dist/unstable-core-do-not-import/transformer.mjs

@@ -1,101 +1,94 @@
-import { isObject } from './utils.mjs';
+import { isObject } from "./utils.mjs";
 
+//#region src/unstable-core-do-not-import/transformer.ts
 /**
- * @internal
- */ function getDataTransformer(transformer) {
-    if ('input' in transformer) {
-        return transformer;
-    }
-    return {
-        input: transformer,
-        output: transformer
-    };
+* @internal
+*/
+function getDataTransformer(transformer) {
+	if ("input" in transformer) return transformer;
+	return {
+		input: transformer,
+		output: transformer
+	};
 }
 /**
- * @internal
- */ const defaultTransformer = {
-    input: {
-        serialize: (obj)=>obj,
-        deserialize: (obj)=>obj
-    },
-    output: {
-        serialize: (obj)=>obj,
-        deserialize: (obj)=>obj
-    }
+* @internal
+*/
+const defaultTransformer = {
+	input: {
+		serialize: (obj) => obj,
+		deserialize: (obj) => obj
+	},
+	output: {
+		serialize: (obj) => obj,
+		deserialize: (obj) => obj
+	}
 };
 function transformTRPCResponseItem(config, item) {
-    if ('error' in item) {
-        return {
-            ...item,
-            error: config.transformer.output.serialize(item.error)
-        };
-    }
-    if ('data' in item.result) {
-        return {
-            ...item,
-            result: {
-                ...item.result,
-                data: config.transformer.output.serialize(item.result.data)
-            }
-        };
-    }
-    return item;
+	if ("error" in item) return {
+		...item,
+		error: config.transformer.output.serialize(item.error)
+	};
+	if ("data" in item.result) return {
+		...item,
+		result: {
+			...item.result,
+			data: config.transformer.output.serialize(item.result.data)
+		}
+	};
+	return item;
 }
 /**
- * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
- **/ function transformTRPCResponse(config, itemOrItems) {
-    return Array.isArray(itemOrItems) ? itemOrItems.map((item)=>transformTRPCResponseItem(config, item)) : transformTRPCResponseItem(config, itemOrItems);
+* Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
+**/
+function transformTRPCResponse(config, itemOrItems) {
+	return Array.isArray(itemOrItems) ? itemOrItems.map((item) => transformTRPCResponseItem(config, item)) : transformTRPCResponseItem(config, itemOrItems);
 }
-// FIXME:
-// - the generics here are probably unnecessary
-// - the RPC-spec could probably be simplified to combine HTTP + WS
-/** @internal */ function transformResultInner(response, transformer) {
-    if ('error' in response) {
-        const error = transformer.deserialize(response.error);
-        return {
-            ok: false,
-            error: {
-                ...response,
-                error
-            }
-        };
-    }
-    const result = {
-        ...response.result,
-        ...(!response.result.type || response.result.type === 'data') && {
-            type: 'data',
-            data: transformer.deserialize(response.result.data)
-        }
-    };
-    return {
-        ok: true,
-        result
-    };
-}
-class TransformResultError extends Error {
-    constructor(){
-        super('Unable to transform response from server');
-    }
+/** @internal */
+function transformResultInner(response, transformer) {
+	if ("error" in response) {
+		const error = transformer.deserialize(response.error);
+		return {
+			ok: false,
+			error: {
+				...response,
+				error
+			}
+		};
+	}
+	const result = {
+		...response.result,
+		...(!response.result.type || response.result.type === "data") && {
+			type: "data",
+			data: transformer.deserialize(response.result.data)
+		}
+	};
+	return {
+		ok: true,
+		result
+	};
 }
+var TransformResultError = class extends Error {
+	constructor() {
+		super("Unable to transform response from server");
+	}
+};
 /**
- * Transforms and validates that the result is a valid TRPCResponse
- * @internal
- */ function transformResult(response, transformer) {
-    let result;
-    try {
-        // Use the data transformers on the JSON-response
-        result = transformResultInner(response, transformer);
-    } catch  {
-        throw new TransformResultError();
-    }
-    // check that output of the transformers is a valid TRPCResponse
-    if (!result.ok && (!isObject(result.error.error) || typeof result.error.error['code'] !== 'number')) {
-        throw new TransformResultError();
-    }
-    if (result.ok && !isObject(result.result)) {
-        throw new TransformResultError();
-    }
-    return result;
+* Transforms and validates that the result is a valid TRPCResponse
+* @internal
+*/
+function transformResult(response, transformer) {
+	let result;
+	try {
+		result = transformResultInner(response, transformer);
+	} catch {
+		throw new TransformResultError();
+	}
+	if (!result.ok && (!isObject(result.error.error) || typeof result.error.error["code"] !== "number")) throw new TransformResultError();
+	if (result.ok && !isObject(result.result)) throw new TransformResultError();
+	return result;
 }
 
+//#endregion
 export { defaultTransformer, getDataTransformer, transformResult, transformTRPCResponse };
+//# sourceMappingURL=transformer.mjs.map

package/dist/unstable-core-do-not-import/transformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.mjs","names":["transformer: DataTransformerOptions","defaultTransformer: CombinedDataTransformer","config: RootConfig<AnyRootTypes>","item: TResponseItem","itemOrItems: TResponse","response:\n    | TRPCResponse<TOutput, inferRouterError<TRouter>>\n    | TRPCResponseMessage<TOutput, inferRouterError<TRouter>>","transformer: DataTransformer","result: ReturnType<typeof transformResultInner>"],"sources":["../../src/unstable-core-do-not-import/transformer.ts"],"sourcesContent":["import type { AnyRootTypes, RootConfig } from './rootConfig';\nimport type { AnyRouter, inferRouterError } from './router';\nimport type {\n  TRPCResponse,\n  TRPCResponseMessage,\n  TRPCResultMessage,\n} from './rpc';\nimport { isObject } from './utils';\n\n/**\n * @public\n */\nexport interface DataTransformer {\n  serialize: (object: any) => any;\n  deserialize: (object: any) => any;\n}\n\ninterface InputDataTransformer extends DataTransformer {\n  /**\n   * This function runs **on the client** before sending the data to the server.\n   */\n  serialize: (object: any) => any;\n  /**\n   * This function runs **on the server** to transform the data before it is passed to the resolver\n   */\n  deserialize: (object: any) => any;\n}\n\ninterface OutputDataTransformer extends DataTransformer {\n  /**\n   * This function runs **on the server** before sending the data to the client.\n   */\n  serialize: (object: any) => any;\n  /**\n   * This function runs **only on the client** to transform the data sent from the server.\n   */\n  deserialize: (object: any) => any;\n}\n\n/**\n * @public\n */\nexport interface CombinedDataTransformer {\n  /**\n   * Specify how the data sent from the client to the server should be transformed.\n   */\n  input: InputDataTransformer;\n  /**\n   * Specify how the data sent from the server to the client should be transformed.\n   */\n  output: OutputDataTransformer;\n}\n\n/**\n * @public\n */\nexport type CombinedDataTransformerClient = {\n  input: Pick<CombinedDataTransformer['input'], 'serialize'>;\n  output: Pick<CombinedDataTransformer['output'], 'deserialize'>;\n};\n\n/**\n * @public\n */\nexport type DataTransformerOptions = CombinedDataTransformer | DataTransformer;\n\n/**\n * @internal\n */\nexport function getDataTransformer(\n  transformer: DataTransformerOptions,\n): CombinedDataTransformer {\n  if ('input' in transformer) {\n    return transformer;\n  }\n  return { input: transformer, output: transformer };\n}\n\n/**\n * @internal\n */\nexport const defaultTransformer: CombinedDataTransformer = {\n  input: { serialize: (obj) => obj, deserialize: (obj) => obj },\n  output: { serialize: (obj) => obj, deserialize: (obj) => obj },\n};\n\nfunction transformTRPCResponseItem<\n  TResponseItem extends TRPCResponse | TRPCResponseMessage,\n>(config: RootConfig<AnyRootTypes>, item: TResponseItem): TResponseItem {\n  if ('error' in item) {\n    return {\n      ...item,\n      error: config.transformer.output.serialize(item.error),\n    };\n  }\n\n  if ('data' in item.result) {\n    return {\n      ...item,\n      result: {\n        ...item.result,\n        data: config.transformer.output.serialize(item.result.data),\n      },\n    };\n  }\n\n  return item;\n}\n\n/**\n * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers\n **/\nexport function transformTRPCResponse<\n  TResponse extends\n    | TRPCResponse\n    | TRPCResponse[]\n    | TRPCResponseMessage\n    | TRPCResponseMessage[],\n>(config: RootConfig<AnyRootTypes>, itemOrItems: TResponse) {\n  return Array.isArray(itemOrItems)\n    ? itemOrItems.map((item) => transformTRPCResponseItem(config, item))\n    : transformTRPCResponseItem(config, itemOrItems);\n}\n\n// FIXME:\n// - the generics here are probably unnecessary\n// - the RPC-spec could probably be simplified to combine HTTP + WS\n/** @internal */\nfunction transformResultInner<TRouter extends AnyRouter, TOutput>(\n  response:\n    | TRPCResponse<TOutput, inferRouterError<TRouter>>\n    | TRPCResponseMessage<TOutput, inferRouterError<TRouter>>,\n  transformer: DataTransformer,\n) {\n  if ('error' in response) {\n    const error = transformer.deserialize(\n      response.error,\n    ) as inferRouterError<TRouter>;\n    return {\n      ok: false,\n      error: {\n        ...response,\n        error,\n      },\n    } as const;\n  }\n\n  const result = {\n    ...response.result,\n    ...((!response.result.type || response.result.type === 'data') && {\n      type: 'data',\n      data: transformer.deserialize(response.result.data),\n    }),\n  } as TRPCResultMessage<TOutput>['result'];\n  return { ok: true, result } as const;\n}\n\nclass TransformResultError extends Error {\n  constructor() {\n    super('Unable to transform response from server');\n  }\n}\n\n/**\n * Transforms and validates that the result is a valid TRPCResponse\n * @internal\n */\nexport function transformResult<TRouter extends AnyRouter, TOutput>(\n  response:\n    | TRPCResponse<TOutput, inferRouterError<TRouter>>\n    | TRPCResponseMessage<TOutput, inferRouterError<TRouter>>,\n  transformer: DataTransformer,\n): ReturnType<typeof transformResultInner> {\n  let result: ReturnType<typeof transformResultInner>;\n  try {\n    // Use the data transformers on the JSON-response\n    result = transformResultInner(response, transformer);\n  } catch {\n    throw new TransformResultError();\n  }\n\n  // check that output of the transformers is a valid TRPCResponse\n  if (\n    !result.ok &&\n    (!isObject(result.error.error) ||\n      typeof result.error.error['code'] !== 'number')\n  ) {\n    throw new TransformResultError();\n  }\n  if (result.ok && !isObject(result.result)) {\n    throw new TransformResultError();\n  }\n  return result;\n}\n"],"mappings":";;;;;;AAqEA,SAAgB,mBACdA,aACyB;AACzB,KAAI,WAAW,YACb,QAAO;AAET,QAAO;EAAE,OAAO;EAAa,QAAQ;CAAa;AACnD;;;;AAKD,MAAaC,qBAA8C;CACzD,OAAO;EAAE,WAAW,CAAC,QAAQ;EAAK,aAAa,CAAC,QAAQ;CAAK;CAC7D,QAAQ;EAAE,WAAW,CAAC,QAAQ;EAAK,aAAa,CAAC,QAAQ;CAAK;AAC/D;AAED,SAAS,0BAEPC,QAAkCC,MAAoC;AACtE,KAAI,WAAW,KACb,QAAO;EACL,GAAG;EACH,OAAO,OAAO,YAAY,OAAO,UAAU,KAAK,MAAM;CACvD;AAGH,KAAI,UAAU,KAAK,OACjB,QAAO;EACL,GAAG;EACH,QAAQ;GACN,GAAG,KAAK;GACR,MAAM,OAAO,YAAY,OAAO,UAAU,KAAK,OAAO,KAAK;EAC5D;CACF;AAGH,QAAO;AACR;;;;AAKD,SAAgB,sBAMdD,QAAkCE,aAAwB;AAC1D,QAAO,MAAM,QAAQ,YAAY,GAC7B,YAAY,IAAI,CAAC,SAAS,0BAA0B,QAAQ,KAAK,CAAC,GAClE,0BAA0B,QAAQ,YAAY;AACnD;;AAMD,SAAS,qBACPC,UAGAC,aACA;AACA,KAAI,WAAW,UAAU;EACvB,MAAM,QAAQ,YAAY,YACxB,SAAS,MACV;AACD,SAAO;GACL,IAAI;GACJ,OAAO;IACL,GAAG;IACH;GACD;EACF;CACF;CAED,MAAM,SAAS;EACb,GAAG,SAAS;EACZ,KAAM,SAAS,OAAO,QAAQ,SAAS,OAAO,SAAS,WAAW;GAChE,MAAM;GACN,MAAM,YAAY,YAAY,SAAS,OAAO,KAAK;EACpD;CACF;AACD,QAAO;EAAE,IAAI;EAAM;CAAQ;AAC5B;AAED,IAAM,uBAAN,cAAmC,MAAM;CACvC,cAAc;AACZ,QAAM,2CAA2C;CAClD;AACF;;;;;AAMD,SAAgB,gBACdD,UAGAC,aACyC;CACzC,IAAIC;AACJ,KAAI;AAEF,WAAS,qBAAqB,UAAU,YAAY;CACrD,QAAO;AACN,QAAM,IAAI;CACX;AAGD,MACG,OAAO,QACN,SAAS,OAAO,MAAM,MAAM,WACrB,OAAO,MAAM,MAAM,YAAY,UAExC,OAAM,IAAI;AAEZ,KAAI,OAAO,OAAO,SAAS,OAAO,OAAO,CACvC,OAAM,IAAI;AAEZ,QAAO;AACR"}

package/dist/unstable-core-do-not-import/types.d.mts

@@ -0,0 +1,116 @@
+//#region src/unstable-core-do-not-import/types.d.ts
+/**
+ * ================================
+ * Useful utility types that doesn't have anything to do with tRPC in particular
+ * ================================
+ */
+/**
+ * @public
+ */
+type Maybe<TType> = TType | null | undefined;
+/**
+ * @internal
+ * @see https://github.com/ianstormtaylor/superstruct/blob/7973400cd04d8ad92bbdc2b6f35acbfb3c934079/src/utils.ts#L323-L325
+ */
+type Simplify<TType> = TType extends any[] | Date ? TType : { [K in keyof TType]: TType[K] };
+/**
+ * @public
+ */
+type Dict<TType> = Record<string, TType | undefined>;
+/**
+ * @public
+ */
+type MaybePromise<TType> = Promise<TType> | TType;
+type FilterKeys<TObj extends object, TFilter> = { [TKey in keyof TObj]: TObj[TKey] extends TFilter ? TKey : never }[keyof TObj];
+/**
+ * @internal
+ */
+type Result<TType, TErr = unknown> = {
+  ok: true;
+  value: TType;
+} | {
+  ok: false;
+  error: TErr;
+};
+/**
+ * @internal
+ */
+type Filter<TObj extends object, TFilter> = Pick<TObj, FilterKeys<TObj, TFilter>>;
+/**
+ * Unwrap return type if the type is a function (sync or async), else use the type as is
+ * @internal
+ */
+type Unwrap<TType> = TType extends ((...args: any[]) => infer R) ? Awaited<R> : TType;
+/**
+ * Makes the object recursively optional
+ * @internal
+ */
+type DeepPartial<TObject> = TObject extends object ? { [P in keyof TObject]?: DeepPartial<TObject[P]> } : TObject;
+/**
+ * Omits the key without removing a potential union
+ * @internal
+ */
+type DistributiveOmit<TObj, TKey extends keyof any> = TObj extends any ? Omit<TObj, TKey> : never;
+/**
+ * See https://github.com/microsoft/TypeScript/issues/41966#issuecomment-758187996
+ * Fixes issues with iterating over keys of objects with index signatures.
+ * Without this, iterations over keys of objects with index signatures will lose
+ * type information about the keys and only the index signature will remain.
+ * @internal
+ */
+type WithoutIndexSignature<TObj> = { [K in keyof TObj as string extends K ? never : number extends K ? never : K]: TObj[K] };
+/**
+ * @internal
+ * Overwrite properties in `TType` with properties in `TWith`
+ * Only overwrites properties when the type to be overwritten
+ * is an object. Otherwise it will just use the type from `TWith`.
+ */
+type Overwrite<TType, TWith> = TWith extends any ? TType extends object ? { [K in keyof WithoutIndexSignature<TType> | keyof WithoutIndexSignature<TWith>]: K extends keyof TWith ? TWith[K] : K extends keyof TType ? TType[K] : never } & (string extends keyof TWith ? {
+  [key: string]: TWith[string];
+} : number extends keyof TWith ? {
+  [key: number]: TWith[number];
+} : {}) : TWith : never;
+/**
+ * @internal
+ */
+type ValidateShape<TActualShape, TExpectedShape> = TActualShape extends TExpectedShape ? Exclude<keyof TActualShape, keyof TExpectedShape> extends never ? TActualShape : TExpectedShape : never;
+/**
+ * @internal
+ */
+type PickFirstDefined<TType, TPick> = undefined extends TType ? undefined extends TPick ? never : TPick : TType;
+type KeyFromValue<TValue, TType extends Record<PropertyKey, PropertyKey>> = { [K in keyof TType]: TValue extends TType[K] ? K : never }[keyof TType];
+type InvertKeyValue<TType extends Record<PropertyKey, PropertyKey>> = { [TValue in TType[keyof TType]]: KeyFromValue<TValue, TType> };
+/**
+ * ================================
+ * tRPC specific types
+ * ================================
+ */
+/**
+ * @internal
+ */
+type IntersectionError<TKey extends string> = `The property '${TKey}' in your router collides with a built-in method, rename this router or procedure on your backend.`;
+/**
+ * @internal
+ */
+type ProtectedIntersection<TType, TWith> = keyof TType & keyof TWith extends never ? TType & TWith : IntersectionError<string & keyof TType & keyof TWith>;
+/**
+ * @internal
+ * Returns the raw input type of a procedure
+ */
+type GetRawInputFn = () => Promise<unknown>;
+declare const _errorSymbol: unique symbol;
+type ErrorSymbol = typeof _errorSymbol;
+type TypeError<TMessage extends string> = TMessage & {
+  _: typeof _errorSymbol;
+};
+type ValueOf<TObj> = TObj[keyof TObj];
+type coerceAsyncIterableToArray<TValue> = TValue extends AsyncIterable<infer $Inferred> ? $Inferred[] : TValue;
+/**
+ * @internal
+ * Infers the type of the value yielded by an async iterable
+ */
+type inferAsyncIterableYield<T> = T extends AsyncIterable<infer U> ? U : T;
+
+//#endregion
+export { DeepPartial, Dict, DistributiveOmit, ErrorSymbol, Filter, FilterKeys, GetRawInputFn, IntersectionError, InvertKeyValue, KeyFromValue, Maybe, MaybePromise, Overwrite, PickFirstDefined, ProtectedIntersection, Result, Simplify, TypeError, Unwrap, ValidateShape, ValueOf, WithoutIndexSignature, coerceAsyncIterableToArray, inferAsyncIterableYield };
+//# sourceMappingURL=types.d.mts.map

package/dist/unstable-core-do-not-import/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/unstable-core-do-not-import/types.ts"],"sourcesContent":[],"mappings":"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"}