@trpc/server 11.1.3-alpha-tmp-issues-6785.34 → 11.1.3-alpha-tmp-tsdown.24

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

@@ -1,106 +1,96 @@
-'use strict';
-
-var utils = require('./utils.js');
+const require_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_utils.isObject(result.error.error) || typeof result.error.error["code"] !== "number")) throw new TransformResultError();
+	if (result.ok && !require_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,115 @@
+//#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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"}