resultar 1.4.5 → 2.0.0-beta.2

package/dist/index.d.ts

@@ -1 +1,77 @@
-export { d as Result, R as ResultAsync, j as err, e as errAsync, f as fromPromise, a as fromSafePromise, k as fromThrowable, b as fromThrowableAsync, i as ok, o as okAsync, h as safeTry, s as safeTryAsync, m as tryCatch, t as tryCatchAsync, l as unit, u as unitAsync } from './utils.js';
+import { S as unit, _ as err, a as fromPromise, b as safeTry, c as okAsync, d as DisposableResult, f as ErrResult, g as StrictResult, h as ResultOperations, i as errAsync, l as tryCatchAsync, m as Result, n as ResultAsync, o as fromSafePromise, p as OkResult, r as StrictResultAsync, s as fromThrowableAsync, t as DisposableResultAsync, u as unitAsync, v as fromThrowable, x as tryCatch, y as ok } from "./result-async-CxGBicja.js";
+
+//#region src/tagged-error.d.ts
+type Alpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "_";
+type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+type AlphaNumeric = Alpha | Digit;
+type ReservedTemplateVariable = "_tag" | "cause" | "fingerprint" | "message" | "messageTemplate" | "name" | "stack";
+type ConsumeTemplateVariable<Template extends string, Accumulator extends string = ""> = Template extends `${infer Character}${infer Rest}` ? Character extends AlphaNumeric ? ConsumeTemplateVariable<Rest, `${Accumulator}${Character}`> : {
+  readonly rest: Template;
+  readonly variable: Accumulator;
+} : {
+  readonly rest: "";
+  readonly variable: Accumulator;
+};
+type ExtractTemplateVariables<Template extends string> = Template extends `${string}$${infer AfterDollar}` ? AfterDollar extends `${Alpha}${string}` ? ConsumeTemplateVariable<AfterDollar> extends {
+  readonly rest: infer Rest extends string;
+  readonly variable: infer Variable extends string;
+} ? Variable | ExtractTemplateVariables<Rest> : never : ExtractTemplateVariables<AfterDollar> : never;
+type TemplateProps<Template extends string> = [ExtractTemplateVariables<Template>] extends [never] ? Record<never, never> : Readonly<Record<ExtractTemplateVariables<Template>, string | number>>;
+type ReservedVariablesIn<Template extends string> = Extract<ExtractTemplateVariables<Template>, ReservedTemplateVariable>;
+type RejectReservedTemplateVariables<Template extends string> = [ReservedVariablesIn<Template>] extends [never] ? Template : never;
+type ErrorBaseConstructor<Base extends Error = Error> = new (message?: string, options?: ErrorOptions) => Base;
+type ErrorClass<Base extends Error = Error> = new (...args: readonly any[]) => Base;
+type ErrorClassInstance<This> = This extends (new (...args: readonly any[]) => infer Instance) ? Instance : never;
+type ConstructorProps<Template extends string> = TemplateProps<Template> & {
+  readonly cause?: unknown;
+};
+type TaggedErrorConstructorArgs<Template extends string> = [ExtractTemplateVariables<Template>] extends [never] ? [props?: {
+  readonly cause?: unknown;
+}] : [props: ConstructorProps<Template>];
+interface TaggedErrorOptions<Tag extends string, MessageTemplate extends string, Base extends Error = Error> {
+  readonly extends?: ErrorBaseConstructor<Base>;
+  readonly message?: MessageTemplate;
+  readonly name: Tag;
+}
+type TaggedErrorInstance<Tag extends string, MessageTemplate extends string, Base extends Error = Error> = Base & Readonly<TemplateProps<MessageTemplate>> & {
+  readonly _tag: Tag;
+  readonly fingerprint: readonly [Tag, MessageTemplate];
+  readonly messageTemplate: MessageTemplate;
+  findCause<T extends Error>(ErrorClass: ErrorClass<T>): T | undefined;
+  toJSON(): object;
+};
+type TaggedErrorClass<Tag extends string, MessageTemplate extends string, Base extends Error = Error> = {
+  new (...args: TaggedErrorConstructorArgs<MessageTemplate>): TaggedErrorInstance<Tag, MessageTemplate, Base>;
+  readonly tag: Tag;
+  err<This extends new (...args: TaggedErrorConstructorArgs<MessageTemplate>) => Error>(this: This, ...args: TaggedErrorConstructorArgs<MessageTemplate>): ErrResult<never, ErrorClassInstance<This>>;
+  is(value: unknown): value is TaggedErrorInstance<Tag, MessageTemplate, Base>;
+};
+type TaggedEnum<Members extends Record<string, Record<PropertyKey, unknown>>> = { readonly [Tag in keyof Members]: Readonly<Members[Tag]> & {
+  readonly _tag: Tag;
+} }[keyof Members];
+type TaggedErrorLike = Error & {
+  readonly _tag: string;
+};
+type TaggedErrorTags<ErrorType extends Error> = Extract<ErrorType, TaggedErrorLike>["_tag"];
+type ErrorForTag<ErrorType extends Error, Tag extends string> = Extract<ErrorType, {
+  readonly _tag: Tag;
+}>;
+type UntaggedError<ErrorType extends Error> = Exclude<ErrorType, TaggedErrorLike>;
+type MatchHandlers<ErrorType extends Error, ReturnType> = { readonly [Tag in TaggedErrorTags<ErrorType>]: (error: ErrorForTag<ErrorType, Tag>) => ReturnType } & ([UntaggedError<ErrorType>] extends [never] ? {
+  readonly Error?: (error: Error) => ReturnType;
+} : {
+  readonly Error: (error: UntaggedError<ErrorType>) => ReturnType;
+});
+type PartialMatchHandlers<ErrorType extends Error, ReturnType> = Partial<MatchHandlers<ErrorType, ReturnType>>;
+declare const defaultMessageTemplate = "$message";
+declare function isError(value: unknown): value is Error;
+declare function isError<Value>(value: Value): value is Extract<Value, Error>;
+declare const findCause: <T extends Error>(error: Error, ErrorClass: ErrorClass<T>) => T | undefined;
+declare function createTaggedError<const Tag extends string, const MessageTemplate extends string = typeof defaultMessageTemplate, Base extends Error = Error>(options: Omit<TaggedErrorOptions<Tag, MessageTemplate, Base>, "message"> & {
+  readonly message?: RejectReservedTemplateVariables<MessageTemplate>;
+}): TaggedErrorClass<Tag, MessageTemplate, Base>;
+declare const matchError: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: MatchHandlers<ErrorType, ReturnType>) => ReturnType;
+declare const matchErrorPartial: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: PartialMatchHandlers<ErrorType, ReturnType>, fallback: (error: ErrorType) => ReturnType) => ReturnType;
+//#endregion
+export { DisposableResult, DisposableResultAsync, type ErrResult, type OkResult, Result, ResultAsync, type ResultOperations, type StrictResult, type StrictResultAsync, type TaggedEnum, type TaggedErrorClass, type TaggedErrorInstance, type TaggedErrorOptions, createTaggedError, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isError, matchError, matchErrorPartial, ok, okAsync, safeTry, tryCatch, tryCatchAsync, unit, unitAsync };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,38 +1,128 @@
-import {
-  Result,
-  ResultAsync,
-  err,
-  errAsync,
-  fromPromise,
-  fromSafePromise,
-  fromThrowable,
-  fromThrowableAsync,
-  ok,
-  okAsync,
-  safeTry,
-  safeTryAsync,
-  tryCatch,
-  tryCatchAsync,
-  unit,
-  unitAsync
-} from "./chunk-C3IJPSX2.js";
-import "./chunk-VBI3T5VS.js";
-export {
-  Result,
-  ResultAsync,
-  err,
-  errAsync,
-  fromPromise,
-  fromSafePromise,
-  fromThrowable,
-  fromThrowableAsync,
-  ok,
-  okAsync,
-  safeTry,
-  safeTryAsync,
-  tryCatch,
-  tryCatchAsync,
-  unit,
-  unitAsync
+import { _ as unit, a as fromSafePromise, c as tryCatchAsync, d as Result, f as err, g as tryCatch, h as safeTry, i as fromPromise, l as unitAsync, m as ok, n as ResultAsync, o as fromThrowableAsync, p as fromThrowable, r as errAsync, s as okAsync, t as DisposableResultAsync, u as DisposableResult } from "./result-async-CdlVdXgX.js";
+//#region src/tagged-error.ts
+const defaultBaseError = Error;
+const defaultMessageTemplate = "$message";
+const nativeError = Error;
+const templateVariableMatcher = /\$([a-zA-Z_][a-zA-Z0-9_]*)/g;
+const reservedTemplateVariables = new Set([
+	"_tag",
+	"cause",
+	"fingerprint",
+	"message",
+	"messageTemplate",
+	"name",
+	"stack"
+]);
+function isError(value) {
+	return nativeError.isError?.(value) ?? value instanceof Error;
+}
+const stringifyTemplateValue = (value) => {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return value.toString();
+	if (typeof value === "symbol") return value.description ?? value.toString();
+	if (typeof value === "function") return value.name;
+	if (typeof value === "object") return value === null ? "null" : JSON.stringify(value) ?? Object.prototype.toString.call(value);
+	return "";
 };
+const compileMessageInterpolator = (template) => (values) => template.replaceAll(templateVariableMatcher, (variable, key) => {
+	const value = values?.[key];
+	return value === void 0 ? variable : stringifyTemplateValue(value);
+});
+const getTemplateVariableNames = (template) => {
+	templateVariableMatcher.lastIndex = 0;
+	return [...template.matchAll(templateVariableMatcher)].map((match) => String(match[1]));
+};
+const assertNoReservedTemplateVariables = (tag, template) => {
+	if (template === defaultMessageTemplate) return;
+	const reservedVariables = getTemplateVariableNames(template).filter((variable) => reservedTemplateVariables.has(variable));
+	if (reservedVariables.length > 0) throw new Error(`createTaggedError(${tag}): reserved template variable $${reservedVariables[0]} is not allowed`);
+};
+const getErrorOptions = (cause) => cause === void 0 ? {} : { cause };
+const assignReadonly = (target, key, value) => {
+	Object.defineProperty(target, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: false
+	});
+};
+const serializeCause = (cause) => {
+	if (!isError(cause)) return cause;
+	return {
+		message: cause.message,
+		name: cause.name,
+		stack: cause.stack
+	};
+};
+const findCause = (error, ErrorClass) => {
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	while (isError(current)) {
+		if (seen.has(current)) break;
+		seen.add(current);
+		if (current instanceof ErrorClass) return current;
+		current = current.cause;
+	}
+};
+function createTaggedError(options) {
+	const BaseError = options.extends ?? defaultBaseError;
+	const messageTemplate = options.message ?? defaultMessageTemplate;
+	assertNoReservedTemplateVariables(options.name, messageTemplate);
+	const interpolate = compileMessageInterpolator(messageTemplate);
+	class GeneratedTaggedError extends BaseError {
+		static tag = options.name;
+		_tag = options.name;
+		fingerprint = [options.name, messageTemplate];
+		messageTemplate = messageTemplate;
+		constructor(props) {
+			const message = interpolate(props);
+			super(message, getErrorOptions(props?.cause));
+			this.name = options.name;
+			if (props) {
+				for (const [key, value] of Object.entries(props)) if (!reservedTemplateVariables.has(key)) assignReadonly(this, key, value);
+			}
+		}
+		static is(value) {
+			return value instanceof this;
+		}
+		static err(...args) {
+			return err(new this(...args));
+		}
+		findCause(ErrorClass) {
+			return findCause(this, ErrorClass);
+		}
+		toJSON() {
+			const json = {
+				_tag: this._tag,
+				fingerprint: this.fingerprint,
+				message: this.message,
+				messageTemplate: this.messageTemplate,
+				name: this.name
+			};
+			if (this.cause !== void 0) json["cause"] = serializeCause(this.cause);
+			for (const [key, value] of Object.entries(this)) if (!(key in json) && key !== "cause" && key !== "stack") json[key] = value;
+			return json;
+		}
+	}
+	return GeneratedTaggedError;
+}
+const matchError = (error, handlers) => {
+	if ("_tag" in error && typeof error._tag === "string" && error._tag in handlers) {
+		const handler = handlers[error._tag];
+		return handler(error);
+	}
+	if (handlers.Error) return handlers.Error(error);
+	throw error;
+};
+const matchErrorPartial = (error, handlers, fallback) => {
+	if ("_tag" in error && typeof error._tag === "string" && error._tag in handlers) {
+		const handler = handlers[error._tag];
+		if (handler) return handler(error);
+	}
+	if (handlers.Error) return handlers.Error(error);
+	return fallback(error);
+};
+//#endregion
+export { DisposableResult, DisposableResultAsync, Result, ResultAsync, createTaggedError, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isError, matchError, matchErrorPartial, ok, okAsync, safeTry, tryCatch, tryCatchAsync, unit, unitAsync };
+
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"index.js","names":["resultErr"],"sources":["../src/tagged-error.ts"],"sourcesContent":["import type { ErrResult } from './result.js'\n\nimport { err as resultErr } from './result.js'\n\ntype Alpha =\n  | 'a'\n  | 'b'\n  | 'c'\n  | 'd'\n  | 'e'\n  | 'f'\n  | 'g'\n  | 'h'\n  | 'i'\n  | 'j'\n  | 'k'\n  | 'l'\n  | 'm'\n  | 'n'\n  | 'o'\n  | 'p'\n  | 'q'\n  | 'r'\n  | 's'\n  | 't'\n  | 'u'\n  | 'v'\n  | 'w'\n  | 'x'\n  | 'y'\n  | 'z'\n  | 'A'\n  | 'B'\n  | 'C'\n  | 'D'\n  | 'E'\n  | 'F'\n  | 'G'\n  | 'H'\n  | 'I'\n  | 'J'\n  | 'K'\n  | 'L'\n  | 'M'\n  | 'N'\n  | 'O'\n  | 'P'\n  | 'Q'\n  | 'R'\n  | 'S'\n  | 'T'\n  | 'U'\n  | 'V'\n  | 'W'\n  | 'X'\n  | 'Y'\n  | 'Z'\n  | '_'\ntype Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'\ntype AlphaNumeric = Alpha | Digit\ntype ReservedTemplateVariable =\n  | '_tag'\n  | 'cause'\n  | 'fingerprint'\n  | 'message'\n  | 'messageTemplate'\n  | 'name'\n  | 'stack'\n\ntype ConsumeTemplateVariable<\n  Template extends string,\n  Accumulator extends string = '',\n> = Template extends `${infer Character}${infer Rest}`\n  ? Character extends AlphaNumeric\n    ? ConsumeTemplateVariable<Rest, `${Accumulator}${Character}`>\n    : { readonly rest: Template; readonly variable: Accumulator }\n  : { readonly rest: ''; readonly variable: Accumulator }\n\ntype ExtractTemplateVariables<Template extends string> =\n  Template extends `${string}$${infer AfterDollar}`\n    ? AfterDollar extends `${Alpha}${string}`\n      ? ConsumeTemplateVariable<AfterDollar> extends {\n          readonly rest: infer Rest extends string\n          readonly variable: infer Variable extends string\n        }\n        ? Variable | ExtractTemplateVariables<Rest>\n        : never\n      : ExtractTemplateVariables<AfterDollar>\n    : never\n\ntype TemplateProps<Template extends string> = [ExtractTemplateVariables<Template>] extends [never]\n  ? Record<never, never>\n  : Readonly<Record<ExtractTemplateVariables<Template>, string | number>>\ntype ReservedVariablesIn<Template extends string> = Extract<\n  ExtractTemplateVariables<Template>,\n  ReservedTemplateVariable\n>\ntype RejectReservedTemplateVariables<Template extends string> = [\n  ReservedVariablesIn<Template>,\n] extends [never]\n  ? Template\n  : never\n\ntype ErrorBaseConstructor<Base extends Error = Error> = new (\n  message?: string,\n  options?: ErrorOptions,\n) => Base\ntype ErrorClass<Base extends Error = Error> = new (...args: readonly any[]) => Base\ntype ErrorClassInstance<This> = This extends new (...args: readonly any[]) => infer Instance\n  ? Instance\n  : never\ntype ConstructorProps<Template extends string> = TemplateProps<Template> & {\n  readonly cause?: unknown\n}\ntype TaggedErrorConstructorArgs<Template extends string> = [\n  ExtractTemplateVariables<Template>,\n] extends [never]\n  ? [props?: { readonly cause?: unknown }]\n  : [props: ConstructorProps<Template>]\n\nexport interface TaggedErrorOptions<\n  Tag extends string,\n  MessageTemplate extends string,\n  Base extends Error = Error,\n> {\n  readonly extends?: ErrorBaseConstructor<Base>\n  readonly message?: MessageTemplate\n  readonly name: Tag\n}\n\nexport type TaggedErrorInstance<\n  Tag extends string,\n  MessageTemplate extends string,\n  Base extends Error = Error,\n> = Base &\n  Readonly<TemplateProps<MessageTemplate>> & {\n    readonly _tag: Tag\n    readonly fingerprint: readonly [Tag, MessageTemplate]\n    readonly messageTemplate: MessageTemplate\n    findCause<T extends Error>(ErrorClass: ErrorClass<T>): T | undefined\n    toJSON(): object\n  }\n\nexport type TaggedErrorClass<\n  Tag extends string,\n  MessageTemplate extends string,\n  Base extends Error = Error,\n> = {\n  new (\n    ...args: TaggedErrorConstructorArgs<MessageTemplate>\n  ): TaggedErrorInstance<Tag, MessageTemplate, Base>\n  readonly tag: Tag\n  err<This extends new (...args: TaggedErrorConstructorArgs<MessageTemplate>) => Error>(\n    this: This,\n    ...args: TaggedErrorConstructorArgs<MessageTemplate>\n  ): ErrResult<never, ErrorClassInstance<This>>\n  is(value: unknown): value is TaggedErrorInstance<Tag, MessageTemplate, Base>\n}\n\nexport type TaggedEnum<Members extends Record<string, Record<PropertyKey, unknown>>> = {\n  readonly [Tag in keyof Members]: Readonly<Members[Tag]> & { readonly _tag: Tag }\n}[keyof Members]\n\ntype TaggedErrorLike = Error & { readonly _tag: string }\ntype TaggedErrorTags<ErrorType extends Error> = Extract<ErrorType, TaggedErrorLike>['_tag']\ntype ErrorForTag<ErrorType extends Error, Tag extends string> = Extract<\n  ErrorType,\n  { readonly _tag: Tag }\n>\ntype UntaggedError<ErrorType extends Error> = Exclude<ErrorType, TaggedErrorLike>\ntype MatchHandlers<ErrorType extends Error, ReturnType> = {\n  readonly [Tag in TaggedErrorTags<ErrorType>]: (error: ErrorForTag<ErrorType, Tag>) => ReturnType\n} & ([UntaggedError<ErrorType>] extends [never]\n  ? { readonly Error?: (error: Error) => ReturnType }\n  : { readonly Error: (error: UntaggedError<ErrorType>) => ReturnType })\ntype PartialMatchHandlers<ErrorType extends Error, ReturnType> = Partial<\n  MatchHandlers<ErrorType, ReturnType>\n>\n\nconst defaultBaseError: ErrorBaseConstructor = Error\nconst defaultMessageTemplate = '$message'\n\nconst nativeError = Error as typeof Error & { isError?: (value: unknown) => boolean }\nconst templateVariableMatcher = /\\$([a-zA-Z_][a-zA-Z0-9_]*)/g\nconst reservedTemplateVariables = new Set<ReservedTemplateVariable>([\n  '_tag',\n  'cause',\n  'fingerprint',\n  'message',\n  'messageTemplate',\n  'name',\n  'stack',\n])\n\nexport function isError(value: unknown): value is Error\nexport function isError<Value>(value: Value): value is Extract<Value, Error>\nexport function isError(value: unknown): value is Error {\n  return nativeError.isError?.(value) ?? value instanceof Error\n}\n\nconst stringifyTemplateValue = (value: unknown): string => {\n  if (typeof value === 'string') {\n    return value\n  }\n\n  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {\n    return value.toString()\n  }\n\n  if (typeof value === 'symbol') {\n    return value.description ?? value.toString()\n  }\n\n  if (typeof value === 'function') {\n    return value.name\n  }\n\n  if (typeof value === 'object') {\n    return value === null\n      ? 'null'\n      : (JSON.stringify(value) ?? Object.prototype.toString.call(value))\n  }\n\n  return ''\n}\n\nconst compileMessageInterpolator =\n  (template: string): ((values?: Record<string, unknown>) => string) =>\n  (values) =>\n    template.replaceAll(templateVariableMatcher, (variable, key: string) => {\n      const value = values?.[key]\n      return value === undefined ? variable : stringifyTemplateValue(value)\n    })\n\nconst getTemplateVariableNames = (template: string): readonly string[] => {\n  templateVariableMatcher.lastIndex = 0\n  return [...template.matchAll(templateVariableMatcher)].map((match) => String(match[1]))\n}\n\nconst assertNoReservedTemplateVariables = (tag: string, template: string): void => {\n  if (template === defaultMessageTemplate) {\n    return\n  }\n\n  const reservedVariables = getTemplateVariableNames(template).filter(\n    (variable): variable is ReservedTemplateVariable =>\n      reservedTemplateVariables.has(variable as ReservedTemplateVariable),\n  )\n\n  if (reservedVariables.length > 0) {\n    throw new Error(\n      `createTaggedError(${tag}): reserved template variable $${reservedVariables[0]} is not allowed`,\n    )\n  }\n}\n\nconst getErrorOptions = (cause: unknown): { cause?: unknown } =>\n  cause === undefined ? {} : { cause }\n\nconst assignReadonly = (target: object, key: PropertyKey, value: unknown): void => {\n  Object.defineProperty(target, key, {\n    configurable: true,\n    enumerable: true,\n    value,\n    writable: false,\n  })\n}\n\nconst serializeCause = (cause: unknown): unknown => {\n  if (!isError(cause)) {\n    return cause\n  }\n\n  return { message: cause.message, name: cause.name, stack: cause.stack }\n}\n\nexport const findCause = <T extends Error>(\n  error: Error,\n  ErrorClass: ErrorClass<T>,\n): T | undefined => {\n  const seen = new Set<Error>()\n  let current: unknown = error\n\n  while (isError(current)) {\n    if (seen.has(current)) {\n      break\n    }\n\n    seen.add(current)\n\n    if (current instanceof ErrorClass) {\n      return current\n    }\n\n    current = current.cause\n  }\n\n  return undefined\n}\n\nexport function createTaggedError<\n  const Tag extends string,\n  const MessageTemplate extends string = typeof defaultMessageTemplate,\n  Base extends Error = Error,\n>(\n  options: Omit<TaggedErrorOptions<Tag, MessageTemplate, Base>, 'message'> & {\n    readonly message?: RejectReservedTemplateVariables<MessageTemplate>\n  },\n): TaggedErrorClass<Tag, MessageTemplate, Base> {\n  const BaseError = options.extends ?? defaultBaseError\n  const messageTemplate = options.message ?? (defaultMessageTemplate as MessageTemplate)\n  assertNoReservedTemplateVariables(options.name, messageTemplate)\n  const interpolate = compileMessageInterpolator(messageTemplate)\n\n  class GeneratedTaggedError extends BaseError {\n    static readonly tag = options.name\n    readonly _tag = options.name\n    readonly fingerprint = [options.name, messageTemplate] as const\n    readonly messageTemplate = messageTemplate\n\n    constructor(props?: ConstructorProps<MessageTemplate>) {\n      const message = interpolate(props)\n      super(message, getErrorOptions(props?.cause))\n      // eslint-disable-next-line nicorn/custom-error-definition\n      this.name = options.name\n\n      if (props) {\n        for (const [key, value] of Object.entries(props)) {\n          if (!reservedTemplateVariables.has(key as ReservedTemplateVariable)) {\n            assignReadonly(this, key, value)\n          }\n        }\n      }\n    }\n\n    static is(value: unknown): value is TaggedErrorInstance<Tag, MessageTemplate, Base> {\n      return value instanceof this\n    }\n\n    static err<This extends new (...args: TaggedErrorConstructorArgs<MessageTemplate>) => Error>(\n      this: This,\n      ...args: TaggedErrorConstructorArgs<MessageTemplate>\n    ): ErrResult<never, InstanceType<This>> {\n      const error = new this(...args) as InstanceType<This>\n      return resultErr<never, InstanceType<This>>(error)\n    }\n\n    findCause<T extends Error>(ErrorClass: ErrorClass<T>): T | undefined {\n      return findCause(this, ErrorClass)\n    }\n\n    toJSON(): object {\n      const json: Record<string, unknown> = {\n        _tag: this._tag,\n        fingerprint: this.fingerprint,\n        message: this.message,\n        messageTemplate: this.messageTemplate,\n        name: this.name,\n      }\n\n      if (this.cause !== undefined) {\n        json['cause'] = serializeCause(this.cause)\n      }\n\n      for (const [key, value] of Object.entries(this)) {\n        if (!(key in json) && key !== 'cause' && key !== 'stack') {\n          json[key] = value\n        }\n      }\n\n      return json\n    }\n  }\n\n  return GeneratedTaggedError as TaggedErrorClass<Tag, MessageTemplate, Base>\n}\n\nexport const matchError = <ErrorType extends Error, ReturnType>(\n  error: ErrorType,\n  handlers: MatchHandlers<ErrorType, ReturnType>,\n): ReturnType => {\n  if ('_tag' in error && typeof error._tag === 'string' && error._tag in handlers) {\n    const handler = handlers[error._tag as keyof typeof handlers] as (\n      error: ErrorType,\n    ) => ReturnType\n    return handler(error)\n  }\n\n  if (handlers.Error) {\n    return (handlers.Error as (error: ErrorType) => ReturnType)(error)\n  }\n\n  throw error\n}\n\nexport const matchErrorPartial = <ErrorType extends Error, ReturnType>(\n  error: ErrorType,\n  handlers: PartialMatchHandlers<ErrorType, ReturnType>,\n  fallback: (error: ErrorType) => ReturnType,\n): ReturnType => {\n  if ('_tag' in error && typeof error._tag === 'string' && error._tag in handlers) {\n    const handler = handlers[error._tag as keyof typeof handlers]\n    if (handler) {\n      return (handler as (error: ErrorType) => ReturnType)(error)\n    }\n  }\n\n  if (handlers.Error) {\n    return (handlers.Error as (error: ErrorType) => ReturnType)(error)\n  }\n\n  return fallback(error)\n}\n"],"mappings":"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"}

package/dist/no-discard.d.ts

@@ -0,0 +1,18 @@
+import { m as Result } from "./result-async-CxGBicja.js";
+
+//#region src/no-discard.d.ts
+interface NoDiscardFinding {
+  readonly column: number;
+  readonly file: string;
+  readonly line: number;
+  readonly type: string;
+}
+interface NoDiscardOptions {
+  readonly project?: string;
+  readonly rootDir?: string;
+}
+declare const findDiscardedResults: (options?: NoDiscardOptions) => Result<readonly NoDiscardFinding[], Error>;
+declare const runNoDiscardCli: (args?: readonly string[]) => number;
+//#endregion
+export { NoDiscardFinding, NoDiscardOptions, findDiscardedResults, runNoDiscardCli };
+//# sourceMappingURL=no-discard.d.ts.map

package/dist/no-discard.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { f as err, m as ok } from "./result-async-CdlVdXgX.js";
+import { relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import ts from "typescript";
+//#region src/no-discard.ts
+const resultTypeMatcher = /\b(?:DisposableResult|DisposableResultAsync|ErrResult|OkResult|Result|ResultAsync|StrictResult|StrictResultAsync)\b/;
+const formatHost = {
+	getCanonicalFileName: (fileName) => fileName,
+	getCurrentDirectory: () => process.cwd(),
+	getNewLine: () => "\n"
+};
+const usage = `Usage: resultar-no-discard [--project tsconfig.json]
+
+Flags:
+  -p, --project <path>  TypeScript project file to inspect. Defaults to tsconfig.json.
+  -h, --help            Show this help message.
+`;
+const cliError = (message) => err(new Error(message));
+const parseArgs = (args) => {
+	let project = void 0;
+	let help = false;
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === "--help" || arg === "-h") help = true;
+		else if (arg === "--project" || arg === "-p") {
+			const nextArg = args[index + 1];
+			if (nextArg === void 0 || nextArg === "") return cliError(`${arg} requires a path`);
+			project = nextArg;
+			index += 1;
+		} else if (arg !== void 0 && arg.startsWith("--project=")) project = arg.slice(10);
+		else if (arg !== void 0 && arg !== "") return cliError(`Unknown argument: ${arg}`);
+	}
+	if (project === "") return cliError("--project requires a path");
+	return project === void 0 ? ok({ help }) : ok({
+		help,
+		project
+	});
+};
+const readProject = (projectPath) => {
+	const config = ts.readConfigFile(projectPath, (fileName) => ts.sys.readFile(fileName));
+	if (config.error) return err(new Error(ts.formatDiagnosticsWithColorAndContext([config.error], formatHost)));
+	const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, resolve(projectPath, ".."), void 0, projectPath);
+	if (parsed.errors.length > 0) return err(new Error(ts.formatDiagnosticsWithColorAndContext(parsed.errors, formatHost)));
+	return ok(parsed);
+};
+const isResultLikeType = (checker, node, type) => {
+	if (type.isUnionOrIntersection()) return type.types.some((innerType) => isResultLikeType(checker, node, innerType));
+	const typeName = checker.typeToString(type, node, ts.TypeFormatFlags.NoTruncation + ts.TypeFormatFlags.UseFullyQualifiedType);
+	return resultTypeMatcher.test(typeName);
+};
+const unwrapExpression = (expression) => {
+	let current = expression;
+	while (ts.isParenthesizedExpression(current)) current = current.expression;
+	return current;
+};
+const isExplicitDiscard = (expression) => ts.isVoidExpression(unwrapExpression(expression));
+const isCallLikeDiscard = (expression) => {
+	const unwrapped = unwrapExpression(expression);
+	if (ts.isAwaitExpression(unwrapped)) return isCallLikeDiscard(unwrapped.expression);
+	if (ts.isCallExpression(unwrapped)) return true;
+	if (ts.isConditionalExpression(unwrapped)) return isCallLikeDiscard(unwrapped.whenTrue) || isCallLikeDiscard(unwrapped.whenFalse);
+	if (ts.isBinaryExpression(unwrapped) && [
+		ts.SyntaxKind.AmpersandAmpersandToken,
+		ts.SyntaxKind.BarBarToken,
+		ts.SyntaxKind.QuestionQuestionToken
+	].includes(unwrapped.operatorToken.kind)) return isCallLikeDiscard(unwrapped.right);
+	return false;
+};
+const inspectSourceFile = (checker, sourceFile) => {
+	const findings = [];
+	const visit = (node) => {
+		if (ts.isExpressionStatement(node) && !isExplicitDiscard(node.expression) && isCallLikeDiscard(node.expression)) {
+			const type = checker.getTypeAtLocation(node.expression);
+			if (isResultLikeType(checker, node.expression, type)) {
+				const position = sourceFile.getLineAndCharacterOfPosition(node.expression.getStart());
+				findings.push({
+					column: position.character + 1,
+					file: sourceFile.fileName,
+					line: position.line + 1,
+					type: checker.typeToString(type, node.expression, ts.TypeFormatFlags.NoTruncation)
+				});
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return findings;
+};
+const findDiscardedResults = (options = {}) => {
+	return readProject(resolve(resolve(options.rootDir ?? process.cwd()), options.project ?? "tsconfig.json")).map((parsed) => {
+		const program = ts.createProgram(parsed.fileNames, parsed.options);
+		const checker = program.getTypeChecker();
+		const findings = [];
+		for (const sourceFile of program.getSourceFiles()) if (!sourceFile.isDeclarationFile && !sourceFile.fileName.includes("/node_modules/")) findings.push(...inspectSourceFile(checker, sourceFile));
+		return findings;
+	});
+};
+const formatFinding = (finding, rootDir) => {
+	return [`${relative(rootDir, finding.file)}:${finding.line}:${finding.column} no-discard-result`, `Ignored ${finding.type} value. Handle it or explicitly discard it with \`void\`.`].join(" - ");
+};
+const runNoDiscardCli = (args = process.argv.slice(2)) => {
+	const rootDir = process.cwd();
+	return parseArgs(args).andThen((options) => {
+		if (!options.help) return options.project === void 0 ? findDiscardedResults({ rootDir }) : findDiscardedResults({
+			project: options.project,
+			rootDir
+		});
+		process.stdout.write(usage);
+		return ok([]);
+	}).match((findings) => {
+		if (findings.length === 0) return 0;
+		process.stderr.write(`${findings.map((finding) => formatFinding(finding, rootDir)).join("\n")}\n`);
+		return 1;
+	}, (error) => {
+		process.stderr.write(`${error.message}\n`);
+		return 1;
+	});
+};
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) process.exitCode = runNoDiscardCli();
+//#endregion
+export { findDiscardedResults, runNoDiscardCli };
+
+//# sourceMappingURL=no-discard.js.map

package/dist/no-discard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-discard.js","names":[],"sources":["../src/no-discard.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { relative, resolve } from 'node:path'\nimport { pathToFileURL } from 'node:url'\n\nimport ts from 'typescript'\n\nimport type { Result } from './result.js'\n\nimport { err, ok } from './result.js'\n\nconst resultTypeMatcher =\n  /\\b(?:DisposableResult|DisposableResultAsync|ErrResult|OkResult|Result|ResultAsync|StrictResult|StrictResultAsync)\\b/\n\nexport interface NoDiscardFinding {\n  readonly column: number\n  readonly file: string\n  readonly line: number\n  readonly type: string\n}\n\nexport interface NoDiscardOptions {\n  readonly project?: string\n  readonly rootDir?: string\n}\n\ninterface CliOptions extends NoDiscardOptions {\n  readonly help: boolean\n}\n\nconst formatHost: ts.FormatDiagnosticsHost = {\n  getCanonicalFileName: (fileName) => fileName,\n  getCurrentDirectory: () => process.cwd(),\n  getNewLine: () => '\\n',\n}\n\nconst usage = `Usage: resultar-no-discard [--project tsconfig.json]\n\nFlags:\n  -p, --project <path>  TypeScript project file to inspect. Defaults to tsconfig.json.\n  -h, --help            Show this help message.\n`\n\nconst cliError = (message: string): Result<never, Error> => err(new Error(message))\n\nconst parseArgs = (args: readonly string[]): Result<CliOptions, Error> => {\n  let project: string | undefined = undefined\n  let help = false\n\n  for (let index = 0; index < args.length; index += 1) {\n    const arg = args[index]\n\n    if (arg === '--help' || arg === '-h') {\n      help = true\n    } else if (arg === '--project' || arg === '-p') {\n      const nextArg = args[index + 1]\n\n      if (nextArg === undefined || nextArg === '') {\n        return cliError(`${arg} requires a path`)\n      }\n\n      project = nextArg\n      index += 1\n    } else if (arg !== undefined && arg.startsWith('--project=')) {\n      project = arg.slice('--project='.length)\n    } else if (arg !== undefined && arg !== '') {\n      return cliError(`Unknown argument: ${arg}`)\n    }\n  }\n\n  if (project === '') {\n    return cliError('--project requires a path')\n  }\n\n  return project === undefined ? ok({ help }) : ok({ help, project })\n}\n\nconst readProject = (projectPath: string): Result<ts.ParsedCommandLine, Error> => {\n  const config = ts.readConfigFile(projectPath, (fileName) => ts.sys.readFile(fileName))\n\n  if (config.error) {\n    return err(new Error(ts.formatDiagnosticsWithColorAndContext([config.error], formatHost)))\n  }\n\n  const parsed = ts.parseJsonConfigFileContent(\n    config.config,\n    ts.sys,\n    resolve(projectPath, '..'),\n    undefined,\n    projectPath,\n  )\n\n  if (parsed.errors.length > 0) {\n    return err(new Error(ts.formatDiagnosticsWithColorAndContext(parsed.errors, formatHost)))\n  }\n\n  return ok(parsed)\n}\n\nconst isResultLikeType = (checker: ts.TypeChecker, node: ts.Node, type: ts.Type): boolean => {\n  if (type.isUnionOrIntersection()) {\n    return type.types.some((innerType) => isResultLikeType(checker, node, innerType))\n  }\n\n  const typeName = checker.typeToString(\n    type,\n    node,\n    ts.TypeFormatFlags.NoTruncation + ts.TypeFormatFlags.UseFullyQualifiedType,\n  )\n\n  return resultTypeMatcher.test(typeName)\n}\n\nconst unwrapExpression = (expression: ts.Expression): ts.Expression => {\n  let current = expression\n\n  while (ts.isParenthesizedExpression(current)) {\n    current = current.expression\n  }\n\n  return current\n}\n\nconst isExplicitDiscard = (expression: ts.Expression): boolean =>\n  ts.isVoidExpression(unwrapExpression(expression))\n\nconst isCallLikeDiscard = (expression: ts.Expression): boolean => {\n  const unwrapped = unwrapExpression(expression)\n\n  if (ts.isAwaitExpression(unwrapped)) {\n    return isCallLikeDiscard(unwrapped.expression)\n  }\n\n  if (ts.isCallExpression(unwrapped)) {\n    return true\n  }\n\n  if (ts.isConditionalExpression(unwrapped)) {\n    return isCallLikeDiscard(unwrapped.whenTrue) || isCallLikeDiscard(unwrapped.whenFalse)\n  }\n\n  if (\n    ts.isBinaryExpression(unwrapped) &&\n    [\n      ts.SyntaxKind.AmpersandAmpersandToken,\n      ts.SyntaxKind.BarBarToken,\n      ts.SyntaxKind.QuestionQuestionToken,\n    ].includes(unwrapped.operatorToken.kind)\n  ) {\n    return isCallLikeDiscard(unwrapped.right)\n  }\n\n  return false\n}\n\nconst inspectSourceFile = (\n  checker: ts.TypeChecker,\n  sourceFile: ts.SourceFile,\n): readonly NoDiscardFinding[] => {\n  const findings: NoDiscardFinding[] = []\n\n  const visit = (node: ts.Node): void => {\n    if (\n      ts.isExpressionStatement(node) &&\n      !isExplicitDiscard(node.expression) &&\n      isCallLikeDiscard(node.expression)\n    ) {\n      const type = checker.getTypeAtLocation(node.expression)\n\n      if (isResultLikeType(checker, node.expression, type)) {\n        const position = sourceFile.getLineAndCharacterOfPosition(node.expression.getStart())\n        findings.push({\n          column: position.character + 1,\n          file: sourceFile.fileName,\n          line: position.line + 1,\n          type: checker.typeToString(type, node.expression, ts.TypeFormatFlags.NoTruncation),\n        })\n      }\n    }\n\n    ts.forEachChild(node, visit)\n  }\n\n  visit(sourceFile)\n\n  return findings\n}\n\nexport const findDiscardedResults = (\n  options: NoDiscardOptions = {},\n): Result<readonly NoDiscardFinding[], Error> => {\n  const rootDir = resolve(options.rootDir ?? process.cwd())\n  const projectPath = resolve(rootDir, options.project ?? 'tsconfig.json')\n\n  return readProject(projectPath).map((parsed) => {\n    const program = ts.createProgram(parsed.fileNames, parsed.options)\n    const checker = program.getTypeChecker()\n    const findings: NoDiscardFinding[] = []\n\n    for (const sourceFile of program.getSourceFiles()) {\n      if (!sourceFile.isDeclarationFile && !sourceFile.fileName.includes('/node_modules/')) {\n        findings.push(...inspectSourceFile(checker, sourceFile))\n      }\n    }\n\n    return findings\n  })\n}\n\nconst formatFinding = (finding: NoDiscardFinding, rootDir: string): string => {\n  const file = relative(rootDir, finding.file)\n\n  return [\n    `${file}:${finding.line}:${finding.column} no-discard-result`,\n    `Ignored ${finding.type} value. Handle it or explicitly discard it with \\`void\\`.`,\n  ].join(' - ')\n}\n\nexport const runNoDiscardCli = (args: readonly string[] = process.argv.slice(2)): number => {\n  const rootDir = process.cwd()\n\n  return parseArgs(args)\n    .andThen((options) => {\n      if (!options.help) {\n        return options.project === undefined\n          ? findDiscardedResults({ rootDir })\n          : findDiscardedResults({ project: options.project, rootDir })\n      }\n\n      process.stdout.write(usage)\n      return ok([] as const)\n    })\n    .match(\n      (findings) => {\n        if (findings.length === 0) {\n          return 0\n        }\n\n        process.stderr.write(\n          `${findings.map((finding) => formatFinding(finding, rootDir)).join('\\n')}\\n`,\n        )\n\n        return 1\n      },\n      (error) => {\n        process.stderr.write(`${error.message}\\n`)\n        return 1\n      },\n    )\n}\n\nif (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {\n  process.exitCode = runNoDiscardCli()\n}\n"],"mappings":";;;;;;AAUA,MAAM,oBACJ;AAkBF,MAAM,aAAuC;CAC3C,uBAAuB,aAAa;CACpC,2BAA2B,QAAQ,KAAK;CACxC,kBAAkB;CACnB;AAED,MAAM,QAAQ;;;;;;AAOd,MAAM,YAAY,YAA0C,IAAI,IAAI,MAAM,QAAQ,CAAC;AAEnF,MAAM,aAAa,SAAuD;CACxE,IAAI,UAA8B,KAAA;CAClC,IAAI,OAAO;AAEX,MAAK,IAAI,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS,GAAG;EACnD,MAAM,MAAM,KAAK;AAEjB,MAAI,QAAQ,YAAY,QAAQ,KAC9B,QAAO;WACE,QAAQ,eAAe,QAAQ,MAAM;GAC9C,MAAM,UAAU,KAAK,QAAQ;AAE7B,OAAI,YAAY,KAAA,KAAa,YAAY,GACvC,QAAO,SAAS,GAAG,IAAI,kBAAkB;AAG3C,aAAU;AACV,YAAS;aACA,QAAQ,KAAA,KAAa,IAAI,WAAW,aAAa,CAC1D,WAAU,IAAI,MAAM,GAAoB;WAC/B,QAAQ,KAAA,KAAa,QAAQ,GACtC,QAAO,SAAS,qBAAqB,MAAM;;AAI/C,KAAI,YAAY,GACd,QAAO,SAAS,4BAA4B;AAG9C,QAAO,YAAY,KAAA,IAAY,GAAG,EAAE,MAAM,CAAC,GAAG,GAAG;EAAE;EAAM;EAAS,CAAC;;AAGrE,MAAM,eAAe,gBAA6D;CAChF,MAAM,SAAS,GAAG,eAAe,cAAc,aAAa,GAAG,IAAI,SAAS,SAAS,CAAC;AAEtF,KAAI,OAAO,MACT,QAAO,IAAI,IAAI,MAAM,GAAG,qCAAqC,CAAC,OAAO,MAAM,EAAE,WAAW,CAAC,CAAC;CAG5F,MAAM,SAAS,GAAG,2BAChB,OAAO,QACP,GAAG,KACH,QAAQ,aAAa,KAAK,EAC1B,KAAA,GACA,YACD;AAED,KAAI,OAAO,OAAO,SAAS,EACzB,QAAO,IAAI,IAAI,MAAM,GAAG,qCAAqC,OAAO,QAAQ,WAAW,CAAC,CAAC;AAG3F,QAAO,GAAG,OAAO;;AAGnB,MAAM,oBAAoB,SAAyB,MAAe,SAA2B;AAC3F,KAAI,KAAK,uBAAuB,CAC9B,QAAO,KAAK,MAAM,MAAM,cAAc,iBAAiB,SAAS,MAAM,UAAU,CAAC;CAGnF,MAAM,WAAW,QAAQ,aACvB,MACA,MACA,GAAG,gBAAgB,eAAe,GAAG,gBAAgB,sBACtD;AAED,QAAO,kBAAkB,KAAK,SAAS;;AAGzC,MAAM,oBAAoB,eAA6C;CACrE,IAAI,UAAU;AAEd,QAAO,GAAG,0BAA0B,QAAQ,CAC1C,WAAU,QAAQ;AAGpB,QAAO;;AAGT,MAAM,qBAAqB,eACzB,GAAG,iBAAiB,iBAAiB,WAAW,CAAC;AAEnD,MAAM,qBAAqB,eAAuC;CAChE,MAAM,YAAY,iBAAiB,WAAW;AAE9C,KAAI,GAAG,kBAAkB,UAAU,CACjC,QAAO,kBAAkB,UAAU,WAAW;AAGhD,KAAI,GAAG,iBAAiB,UAAU,CAChC,QAAO;AAGT,KAAI,GAAG,wBAAwB,UAAU,CACvC,QAAO,kBAAkB,UAAU,SAAS,IAAI,kBAAkB,UAAU,UAAU;AAGxF,KACE,GAAG,mBAAmB,UAAU,IAChC;EACE,GAAG,WAAW;EACd,GAAG,WAAW;EACd,GAAG,WAAW;EACf,CAAC,SAAS,UAAU,cAAc,KAAK,CAExC,QAAO,kBAAkB,UAAU,MAAM;AAG3C,QAAO;;AAGT,MAAM,qBACJ,SACA,eACgC;CAChC,MAAM,WAA+B,EAAE;CAEvC,MAAM,SAAS,SAAwB;AACrC,MACE,GAAG,sBAAsB,KAAK,IAC9B,CAAC,kBAAkB,KAAK,WAAW,IACnC,kBAAkB,KAAK,WAAW,EAClC;GACA,MAAM,OAAO,QAAQ,kBAAkB,KAAK,WAAW;AAEvD,OAAI,iBAAiB,SAAS,KAAK,YAAY,KAAK,EAAE;IACpD,MAAM,WAAW,WAAW,8BAA8B,KAAK,WAAW,UAAU,CAAC;AACrF,aAAS,KAAK;KACZ,QAAQ,SAAS,YAAY;KAC7B,MAAM,WAAW;KACjB,MAAM,SAAS,OAAO;KACtB,MAAM,QAAQ,aAAa,MAAM,KAAK,YAAY,GAAG,gBAAgB,aAAa;KACnF,CAAC;;;AAIN,KAAG,aAAa,MAAM,MAAM;;AAG9B,OAAM,WAAW;AAEjB,QAAO;;AAGT,MAAa,wBACX,UAA4B,EAAE,KACiB;AAI/C,QAAO,YAFa,QADJ,QAAQ,QAAQ,WAAW,QAAQ,KAAK,CAAC,EACpB,QAAQ,WAAW,gBAAgB,CAEzC,CAAC,KAAK,WAAW;EAC9C,MAAM,UAAU,GAAG,cAAc,OAAO,WAAW,OAAO,QAAQ;EAClE,MAAM,UAAU,QAAQ,gBAAgB;EACxC,MAAM,WAA+B,EAAE;AAEvC,OAAK,MAAM,cAAc,QAAQ,gBAAgB,CAC/C,KAAI,CAAC,WAAW,qBAAqB,CAAC,WAAW,SAAS,SAAS,iBAAiB,CAClF,UAAS,KAAK,GAAG,kBAAkB,SAAS,WAAW,CAAC;AAI5D,SAAO;GACP;;AAGJ,MAAM,iBAAiB,SAA2B,YAA4B;AAG5E,QAAO,CACL,GAHW,SAAS,SAAS,QAAQ,KAAK,CAGlC,GAAG,QAAQ,KAAK,GAAG,QAAQ,OAAO,qBAC1C,WAAW,QAAQ,KAAK,2DACzB,CAAC,KAAK,MAAM;;AAGf,MAAa,mBAAmB,OAA0B,QAAQ,KAAK,MAAM,EAAE,KAAa;CAC1F,MAAM,UAAU,QAAQ,KAAK;AAE7B,QAAO,UAAU,KAAK,CACnB,SAAS,YAAY;AACpB,MAAI,CAAC,QAAQ,KACX,QAAO,QAAQ,YAAY,KAAA,IACvB,qBAAqB,EAAE,SAAS,CAAC,GACjC,qBAAqB;GAAE,SAAS,QAAQ;GAAS;GAAS,CAAC;AAGjE,UAAQ,OAAO,MAAM,MAAM;AAC3B,SAAO,GAAG,EAAE,CAAU;GACtB,CACD,OACE,aAAa;AACZ,MAAI,SAAS,WAAW,EACtB,QAAO;AAGT,UAAQ,OAAO,MACb,GAAG,SAAS,KAAK,YAAY,cAAc,SAAS,QAAQ,CAAC,CAAC,KAAK,KAAK,CAAC,IAC1E;AAED,SAAO;KAER,UAAU;AACT,UAAQ,OAAO,MAAM,GAAG,MAAM,QAAQ,IAAI;AAC1C,SAAO;GAEV;;AAGL,IAAI,OAAO,KAAK,QAAQ,cAAc,QAAQ,KAAK,MAAM,GAAG,CAAC,KAC3D,SAAQ,WAAW,iBAAiB"}