@devp0nt/error0 1.0.0-next.4 → 1.0.0-next.40

package/dist/esm/index.js

@@ -1,400 +1,354 @@
-import { Meta0 } from "@devp0nt/meta0";
-import { HttpStatusCode, isAxiosError } from "axios";
-import get from "lodash/get.js";
-import { ZodError } from "zod";
-const isFilled = (value) => value !== null && value !== void 0 && value !== "";
-class Error0 extends Error {
-  __I_AM_ERROR_0 = true;
-  tag;
-  code;
-  httpStatus;
-  expected;
-  clientMessage;
-  anyMessage;
-  cause;
-  meta;
-  zodError;
-  axiosError;
-  static defaultMessage = "Unknown error";
-  static defaultCode;
-  static defaultHttpStatus;
-  static defaultExpected;
-  static defaultClientMessage;
-  static defaultMeta;
-  propsOriginal;
-  constructor(...args) {
-    const input = {};
-    if (args[0] instanceof Error) {
-      input.cause = args[0];
-    } else if (typeof args[0] === "object" && args[0] !== null) {
-      Object.assign(input, args[0]);
-    } else if (typeof args[0] === "string") {
-      input.message = args[0];
-    }
-    if (typeof args[1] === "object" && args[1] !== null) {
-      Object.assign(input, args[1]);
-    }
-    const safeInput = Error0._safeParseInput(input);
-    const message = safeInput.message || Error0.defaultMessage;
-    super(message);
-    Object.setPrototypeOf(this, this.constructor.prototype);
-    this.name = "Error0";
-    this.propsOriginal = this.constructor._getSelfGeneralProps({
-      error0Input: safeInput,
-      message,
-      stack: safeInput.stack || this.stack
-    });
-    const causesProps = this.constructor._getCausesPropsFromError0Props(
-      this.propsOriginal,
-      this.constructor.defaultMaxLevel
-    );
-    const propsFloated = this.constructor._getSelfPropsFloated(causesProps);
-    this.tag = propsFloated.tag;
-    this.code = propsFloated.code;
-    this.httpStatus = propsFloated.httpStatus;
-    this.expected = propsFloated.expected;
-    this.clientMessage = propsFloated.clientMessage;
-    this.cause = propsFloated.cause;
-    this.stack = propsFloated.stack;
-    this.meta = propsFloated.meta;
-    this.zodError = propsFloated.zodError;
-    this.axiosError = propsFloated.axiosError;
-  }
-  // settings
-  static defaultMaxLevel = 10;
-  // props
-  static _safeParseInput(error0Input) {
-    const result = {};
-    result.message = typeof error0Input.message === "string" ? error0Input.message : void 0;
-    result.tag = typeof error0Input.tag === "string" ? error0Input.tag : void 0;
-    result.code = typeof error0Input.code === "string" ? error0Input.code : void 0;
-    result.httpStatus = typeof error0Input.httpStatus === "number" || typeof error0Input.httpStatus === "string" ? error0Input.httpStatus : void 0;
-    result.expected = typeof error0Input.expected === "function" || typeof error0Input.expected === "boolean" ? error0Input.expected : void 0;
-    result.clientMessage = typeof error0Input.clientMessage === "string" ? error0Input.clientMessage : void 0;
-    result.cause = error0Input.cause;
-    result.stack = typeof error0Input.stack === "string" ? error0Input.stack : void 0;
-    result.meta = error0Input.meta instanceof Meta0 ? error0Input.meta : typeof error0Input.meta === "object" && error0Input.meta !== null ? error0Input.meta : void 0;
-    result.zodError = error0Input.zodError instanceof ZodError ? error0Input.zodError : void 0;
-    result.axiosError = isAxiosError(error0Input.axiosError) ? error0Input.axiosError : void 0;
-    return result;
-  }
-  static _getSelfGeneralProps({
-    error0Input,
-    message,
-    stack
-  }) {
-    const meta0 = Meta0.extend(error0Input.meta, this.defaultMeta);
-    const meta = meta0.getValue();
-    const finalTag = meta0.getFinalTag(error0Input.tag);
-    const clientMessage = error0Input.clientMessage || this.defaultClientMessage;
-    const result = {
-      message: error0Input.message || this.defaultMessage,
-      tag: finalTag,
-      code: error0Input.code || meta.code || this.defaultCode,
-      httpStatus: typeof error0Input.httpStatus === "number" ? error0Input.httpStatus : error0Input.httpStatus && typeof error0Input.httpStatus === "string" && error0Input.httpStatus in HttpStatusCode ? HttpStatusCode[error0Input.httpStatus] : meta.httpStatus || this.defaultHttpStatus,
-      expected: void 0,
-      clientMessage,
-      anyMessage: clientMessage || message,
-      cause: error0Input.cause,
-      stack: void 0,
-      meta,
-      zodError: error0Input.zodError,
-      axiosError: error0Input.axiosError
+class ExtensionError0 {
+  _extension;
+  Infer = void 0;
+  constructor(extension) {
+    this._extension = {
+      props: { ...extension?.props ?? {} },
+      computed: { ...extension?.computed ?? {} },
+      methods: { ...extension?.methods ?? {} },
+      refine: [...extension?.refine ?? []]
     };
-    result.expected = this._normalizeSelfExpected(
-      result,
-      typeof error0Input.expected === "boolean" || typeof error0Input.expected === "function" ? error0Input.expected : meta.expected || this.defaultExpected
-    );
-    result.stack = this._removeConstructorStackPart(stack);
-    return result;
   }
-  static _getSelfPropsFloated(causesProps) {
-    const cause = this._getClosestPropValue(causesProps, "cause");
-    const stack = this._mergeStack(causesProps[1]?.stack, causesProps[0]?.stack);
-    const closestTag = this._getClosestPropValue(causesProps, "tag");
-    const meta = this._getMergedMetaValue(causesProps);
-    const tag = Meta0.getFinalTag(meta, closestTag);
-    const propsFloated = {
-      message: this._getClosestPropValue(causesProps, "message"),
-      tag,
-      code: this._getClosestPropValue(causesProps, "code"),
-      httpStatus: this._getClosestPropValue(causesProps, "httpStatus"),
-      expected: this._isExpected(causesProps),
-      clientMessage: this._getClosestPropValue(causesProps, "clientMessage"),
-      cause,
-      stack,
-      anyMessage: causesProps[0].anyMessage,
-      meta,
-      zodError: this._getClosestPropValue(causesProps, "zodError"),
-      axiosError: this._getClosestPropValue(causesProps, "axiosError")
-    };
-    return propsFloated;
+  prop(key, value) {
+    return this.extend("prop", key, value);
   }
-  // sepcial
-  static _getExtraError0PropsByZodError(zodError) {
-    return {
-      message: `Zod Validation Error: ${zodError.message}`
-    };
+  computed(key, value) {
+    return this.extend("computed", key, value);
   }
-  static _getExtraError0PropsByAxiosError(axiosError) {
-    return {
-      message: "Axios Error",
-      meta: {
-        axiosData: (() => {
-          try {
-            return JSON.stringify(axiosError.response?.data);
-          } catch {
-            return void 0;
-          }
-        })(),
-        axiosStatus: axiosError.response?.status
-      }
-    };
+  method(key, value) {
+    return this.extend("method", key, value);
   }
-  static _assignError0Props(error0Props, extraError0Props) {
-    const metaValue = Meta0.mergeValues(error0Props.meta, extraError0Props.meta);
-    Object.assign(error0Props, extraError0Props, { meta: metaValue });
+  refine(value) {
+    return this.extend("refine", value);
   }
-  // expected
-  static _normalizeSelfExpected(error0Props, expectedProvided) {
-    if (typeof expectedProvided === "function") {
-      return expectedProvided(error0Props);
-    }
-    return expectedProvided;
-  }
-  static _isExpected(causesProps) {
-    let hasExpectedTrue = false;
-    for (const causeProps of causesProps) {
-      if (causeProps.expected === false) {
-        return false;
+  extend(kind, keyOrValue, value) {
+    const nextProps = { ...this._extension.props ?? {} };
+    const nextComputed = { ...this._extension.computed ?? {} };
+    const nextMethods = { ...this._extension.methods ?? {} };
+    const nextRefine = [
+      ...this._extension.refine ?? []
+    ];
+    if (kind === "prop") {
+      const key = keyOrValue;
+      if (value === void 0) {
+        throw new Error('ExtensionError0.extend("prop", key, value) requires value');
       }
-      if (causeProps.expected === true) {
-        hasExpectedTrue = true;
+      nextProps[key] = value;
+    } else if (kind === "computed") {
+      const key = keyOrValue;
+      if (value === void 0) {
+        throw new Error('ExtensionError0.extend("computed", key, value) requires value');
       }
+      nextComputed[key] = value;
+    } else if (kind === "method") {
+      const key = keyOrValue;
+      if (value === void 0) {
+        throw new Error('ExtensionError0.extend("method", key, value) requires value');
+      }
+      nextMethods[key] = value;
+    } else {
+      nextRefine.push(keyOrValue);
     }
-    return hasExpectedTrue;
+    return new ExtensionError0({
+      props: nextProps,
+      computed: nextComputed,
+      methods: nextMethods,
+      refine: nextRefine
+    });
   }
-  // getters
-  static _getPropsFromUnknown(error, defaults) {
-    if (typeof error !== "object" || error === null) {
-      return {
-        message: void 0,
-        tag: void 0,
-        code: void 0,
-        httpStatus: void 0,
-        expected: void 0,
-        clientMessage: void 0,
-        anyMessage: this.defaultMessage,
-        cause: void 0,
-        stack: void 0,
-        zodError: void 0,
-        axiosError: void 0,
-        meta: {}
-      };
-    }
-    const message = "message" in error && typeof error.message === "string" ? error.message : void 0;
-    const clientMessage = "clientMessage" in error && typeof error.clientMessage === "string" ? error.clientMessage : defaults?.clientMessage || void 0;
-    const result = {
-      message,
-      code: "code" in error && typeof error.code === "string" ? error.code : defaults?.code || void 0,
-      clientMessage,
-      anyMessage: clientMessage || message || this.defaultMessage,
-      expected: void 0,
-      stack: "stack" in error && typeof error.stack === "string" ? error.stack : void 0,
-      tag: "tag" in error && typeof error.tag === "string" ? error.tag : defaults?.tag || void 0,
-      cause: "cause" in error ? error.cause : defaults?.cause || void 0,
-      meta: "meta" in error && typeof error.meta === "object" && error.meta !== null ? Meta0.getValue(error.meta) : Meta0.getValue(defaults?.meta) || {},
-      httpStatus: "httpStatus" in error && typeof error.httpStatus === "number" && error.httpStatus in HttpStatusCode ? error.httpStatus : typeof defaults?.httpStatus === "string" ? HttpStatusCode[defaults.httpStatus] : defaults?.httpStatus,
-      zodError: "zodError" in error && error.zodError instanceof ZodError ? error.zodError : error instanceof ZodError ? error : defaults?.zodError,
-      axiosError: "axiosError" in error && isAxiosError(error.axiosError) ? error.axiosError : isAxiosError(error) ? error : defaults?.axiosError
+}
+class Error0 extends Error {
+  static __extensionsMap;
+  static _extensions = [];
+  static _emptyExtension = {
+    props: {},
+    computed: {},
+    methods: {},
+    refine: []
+  };
+  static _getResolvedExtension() {
+    const resolved = {
+      props: {},
+      computed: {},
+      methods: {},
+      refine: []
     };
-    result.expected = this._normalizeSelfExpected(
-      result,
-      "expected" in error && (typeof error.expected === "boolean" || typeof error.expected === "function") ? error.expected : defaults?.expected || void 0
-    );
-    if (result.zodError) {
-      this._assignError0Props(result, this._getExtraError0PropsByZodError(result.zodError));
+    for (const extension of this._extensions) {
+      Object.assign(resolved.props, extension.props ?? this._emptyExtension.props);
+      Object.assign(resolved.computed, extension.computed ?? this._emptyExtension.computed);
+      Object.assign(resolved.methods, extension.methods ?? this._emptyExtension.methods);
+      resolved.refine.push(...extension.refine ?? this._emptyExtension.refine);
     }
-    if (result.axiosError) {
-      this._assignError0Props(result, this._getExtraError0PropsByAxiosError(result.axiosError));
-    }
-    return result;
+    return resolved;
   }
-  static _getCausesPropsFromUnknown(error, maxLevel) {
-    if (!error) {
-      return [];
-    }
-    const causeProps = this._getPropsFromUnknown(error);
-    const causesProps = [causeProps];
-    if (!causeProps.cause) {
-      return causesProps;
+  constructor(...args) {
+    const [first, second] = args;
+    const input = typeof first === "string" ? { message: first, ...second ?? {} } : first;
+    super(input.message, { cause: input.cause });
+    this.name = "Error0";
+    const ctor = this.constructor;
+    const extension = ctor._getResolvedExtension();
+    for (const [key, prop] of Object.entries(extension.props)) {
+      if (key in input) {
+        const ownValue = input[key];
+        this[key] = prop.input(ownValue);
+      } else {
+        Object.defineProperty(this, key, {
+          get: () => prop.output(this),
+          set: (value) => {
+            Object.defineProperty(this, key, {
+              value,
+              writable: true,
+              enumerable: true,
+              configurable: true
+            });
+          },
+          enumerable: true,
+          configurable: true
+        });
+      }
     }
-    if (maxLevel > 0) {
-      causesProps.push(...this._getCausesPropsFromUnknown(this._getPropsFromUnknown(causeProps.cause), maxLevel - 1));
+    for (const [key, computed] of Object.entries(extension.computed)) {
+      Object.defineProperty(this, key, {
+        get: () => computed(this),
+        set: (value) => {
+          Object.defineProperty(this, key, {
+            value,
+            writable: true,
+            enumerable: true,
+            configurable: true
+          });
+        },
+        enumerable: true,
+        configurable: true
+      });
     }
-    return causesProps;
-  }
-  static _getCausesPropsFromError0Props(error0Props, maxLevel) {
-    return [error0Props, ...this._getCausesPropsFromUnknown(error0Props.cause, maxLevel - 1)];
   }
-  static _getClosestPropValue(causesProps, propKey) {
-    for (const causeProps of causesProps) {
-      const propValue = causeProps[propKey];
-      if (isFilled(propValue)) {
-        return propValue;
+  static isSelfProperty = (object, key) => {
+    const d = Object.getOwnPropertyDescriptor(object, key);
+    if (!d) return false;
+    if (typeof d.get === "function" || typeof d.set === "function") {
+      if ("name" in object && object.name === "Error0") {
+        return false;
+      } else {
+        return true;
       }
     }
+    return true;
+  };
+  static own(error, key) {
+    if (this.isSelfProperty(error, key)) {
+      return error[key];
+    }
     return void 0;
   }
-  // private static getClosestByGetter<TResult>(
-  //   causesProps: Error0GeneralProps[],
-  //   getter: (props: Error0GeneralProps) => TResult,
-  // ): NonNullable<TResult> | undefined {
-  //   for (const causeProps of causesProps) {
-  //     const result = getter(causeProps)
-  //     if (isFilled(result)) {
-  //       return result
-  //     }
-  //   }
-  //   return undefined
-  // }
-  static _getFilledPropValues(causesProps, propKey) {
-    const values = [];
-    for (const causeProps of causesProps) {
-      const propValue = causeProps[propKey];
-      if (isFilled(propValue)) {
-        values.push(propValue);
+  own(key) {
+    const ctor = this.constructor;
+    return ctor.own(this, key);
+  }
+  static flow(error, key, policy = "likeError0") {
+    return this.causes(error, policy).map((cause) => {
+      const causeRecord = cause;
+      if (this.isSelfProperty(causeRecord, key)) {
+        return causeRecord[key];
       }
-    }
-    return values;
+      return void 0;
+    });
   }
-  static _getMergedMetaValue(causesProps) {
-    const metas = this._getFilledPropValues(causesProps, "meta");
-    if (metas.length === 0) {
-      return {};
-    } else if (metas.length === 1) {
-      return metas[0];
-    } else {
-      return Meta0.mergeValues(metas[0], ...metas.slice(1));
-    }
+  flow(key, policy = "likeError0") {
+    const ctor = this.constructor;
+    return ctor.flow(this, key, policy);
   }
-  // stack
-  static _removeConstructorStackPart(stack) {
-    if (!stack) {
-      return stack;
+  static causes(error, policy = "all") {
+    const causes = [];
+    let current = error;
+    const maxDepth = 99;
+    const seen = /* @__PURE__ */ new Set();
+    for (let depth = 0; depth < maxDepth; depth += 1) {
+      if (!current || typeof current !== "object") {
+        break;
+      }
+      if (seen.has(current)) {
+        break;
+      }
+      if (policy === "instance") {
+        if (!this.is(current)) {
+          break;
+        }
+      } else if (policy === "error0") {
+        if (!this.isError0(current)) {
+          break;
+        }
+      } else if (policy === "likeError0") {
+        if (!this.isLikeError0(current)) {
+          break;
+        }
+      }
+      seen.add(current);
+      causes.push(current);
+      current = current.cause;
     }
-    let lines = stack.split("\n");
-    const removeAllLinesContains = (search) => {
-      lines = lines.filter((line) => !line.includes(search));
-    };
-    removeAllLinesContains("at new Error0");
-    removeAllLinesContains("at _toError0");
-    removeAllLinesContains("at Error0.from");
-    removeAllLinesContains("at Error0._toError0");
-    return lines.join("\n");
+    return causes;
+  }
+  causes(policy = "all") {
+    const ctor = this.constructor;
+    return ctor.causes(this, policy);
   }
-  static _mergeStack(prevStack, nextStack) {
-    return [nextStack, prevStack].filter(Boolean).join("\n\n") || void 0;
+  static is(error) {
+    return error instanceof this;
   }
-  // transformations
   static isError0(error) {
     return error instanceof Error0;
   }
-  static isLikelyError0(error) {
-    if (error instanceof Error0) {
-      return true;
-    }
-    if (typeof error === "object" && error !== null) {
-      if ("__I_AM_ERROR_0" in error && error.__I_AM_ERROR_0 === true) {
-        return true;
-      }
-    }
-    return false;
+  static isLikeError0(error) {
+    return error instanceof Error0 || typeof error === "object" && error !== null && "name" in error && error.name === "Error0";
   }
-  static _toError0(error, inputOverride = {}) {
-    if (error instanceof Error0) {
+  static from(error) {
+    if (this.is(error)) {
       return error;
     }
-    if (typeof error === "string") {
-      return new Error0(error, inputOverride);
+    if (this.isLikeError0(error)) {
+      return this._fromLikeError0(error);
     }
+    return this._fromNonError0(error);
+  }
+  static _applyRefine(error) {
+    const extension = this._getResolvedExtension();
+    for (const refine of extension.refine) {
+      const refined = refine(error);
+      if (refined && typeof refined === "object") {
+        Object.assign(error, refined);
+      }
+    }
+    return error;
+  }
+  static _fromLikeError0(error) {
+    const message = this._extractMessage(error);
     if (typeof error !== "object" || error === null) {
-      return new Error0({
-        message: this.defaultMessage,
-        ...inputOverride
-      });
+      return this._applyRefine(new this(message, { cause: error }));
     }
-    const inputFromData = get(error, "data");
-    if (inputFromData) {
-      if (Error0.isLikelyError0(inputFromData)) {
-        return this._toError0(inputFromData, inputOverride);
+    const errorRecord = error;
+    const recreated = new this(message);
+    const temp = new this(message, { cause: errorRecord });
+    const extension = this._getResolvedExtension();
+    for (const [key, prop] of Object.entries(extension.props)) {
+      const value = prop.output(temp);
+      if (value !== void 0) {
+        ;
+        recreated[key] = value;
       }
     }
-    const inputFromDataError0 = get(error, "data.error0");
-    if (inputFromDataError0) {
-      if (Error0.isLikelyError0(inputFromDataError0)) {
-        return this._toError0(inputFromDataError0, inputOverride);
-      }
+    ;
+    recreated.cause = errorRecord.cause;
+    if (typeof errorRecord.stack === "string") {
+      recreated.stack = errorRecord.stack;
     }
-    return new Error0(this._getPropsFromUnknown(error, inputOverride));
+    return this._applyRefine(recreated);
   }
-  static from(error, inputOverride) {
-    return this._toError0(error, inputOverride);
+  static _fromNonError0(error) {
+    const message = this._extractMessage(error);
+    return this._applyRefine(new this(message, { cause: error }));
   }
-  static extend(props) {
-    const parent = this;
-    return class Error0 extends parent {
-      static defaultMessage = props.defaultMessage ?? parent.defaultMessage;
-      static defaultCode = props.defaultCode ?? parent.defaultCode;
-      static defaultHttpStatus = props.defaultHttpStatus ?? parent.defaultHttpStatus;
-      static defaultExpected = props.defaultExpected ?? parent.defaultExpected;
-      static defaultClientMessage = props.defaultClientMessage ?? parent.defaultClientMessage;
-      static defaultMeta = Meta0.extend(props.defaultMeta, parent.defaultMeta);
-    };
+  static _extractMessage(error) {
+    return (typeof error === "string" ? error : typeof error === "object" && error !== null && "message" in error && typeof error.message === "string" ? error.message : void 0) || "Unknown error";
   }
-  static extendCollection(classes, props) {
-    return Object.fromEntries(Object.entries(classes).map(([name, Class]) => [name, Class.extend(props)]));
+  static _extendWithExtension(extension) {
+    const Base = this;
+    const Error0Extended = class Error0 extends Base {
+    };
+    Error0Extended._extensions = [...Base._extensions, extension];
+    const resolved = Error0Extended._getResolvedExtension();
+    for (const [key, method] of Object.entries(resolved.methods)) {
+      Object.defineProperty(Error0Extended.prototype, key, {
+        value: function(...args) {
+          return method(this, ...args);
+        },
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(Error0Extended, key, {
+        value: function(error, ...args) {
+          return method(this.from(error), ...args);
+        },
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+    return Error0Extended;
   }
-  toJSON() {
+  static _extensionFromBuilder(extension) {
+    const extensionRecord = extension;
     return {
-      message: this.message,
-      tag: this.tag,
-      code: this.code,
-      httpStatus: this.httpStatus,
-      expected: this.expected,
-      clientMessage: this.clientMessage,
-      anyMessage: this.anyMessage,
-      cause: this.cause,
-      meta: Meta0.getValue(this.meta),
-      stack: this.stack,
-      __I_AM_ERROR_0: this.__I_AM_ERROR_0
+      props: { ...extensionRecord._extension.props ?? {} },
+      computed: { ...extensionRecord._extension.computed ?? {} },
+      methods: { ...extensionRecord._extension.methods ?? {} },
+      refine: [...extensionRecord._extension.refine ?? []]
     };
   }
-  static toJSON(error, inputOverride) {
-    const error0 = this.from(error, inputOverride);
-    return error0.toJSON();
+  static extend(first, key, value) {
+    if (first instanceof ExtensionError0) {
+      return this._extendWithExtension(this._extensionFromBuilder(first));
+    }
+    if (first === "refine") {
+      if (typeof key !== "function") {
+        throw new Error('Error0.extend("refine", value) requires refine function');
+      }
+      return this._extendWithExtension({
+        refine: [key]
+      });
+    }
+    if (typeof key !== "string" || value === void 0) {
+      throw new Error("Error0.extend(kind, key, value) requires key and value");
+    }
+    if (first === "prop") {
+      return this._extendWithExtension({
+        props: { [key]: value }
+      });
+    }
+    if (first === "computed") {
+      return this._extendWithExtension({
+        computed: { [key]: value }
+      });
+    }
+    return this._extendWithExtension({
+      methods: { [key]: value }
+    });
+  }
+  static extension() {
+    return new ExtensionError0();
   }
-  toResponse(data) {
-    return Response.json(
-      {
-        ...this.toJSON(),
-        ...data
-      },
-      {
-        status: this.httpStatus,
-        statusText: this.message
+  static serialize(error, isPublic = true) {
+    const error0 = this.from(error);
+    const jsonWithUndefined = {
+      name: error0.name,
+      message: error0.message,
+      cause: error0.cause,
+      stack: error0.stack
+    };
+    const extension = this._getResolvedExtension();
+    for (const [key, prop] of Object.entries(extension.props)) {
+      const value = prop.output(error0);
+      const jsonValue = prop.serialize(value, error0, isPublic);
+      if (jsonValue !== void 0) {
+        jsonWithUndefined[key] = jsonValue;
+      } else {
+        try {
+          delete jsonWithUndefined[key];
+        } catch {
+        }
       }
-    );
+    }
+    return Object.fromEntries(Object.entries(jsonWithUndefined).filter(([, value]) => value !== void 0));
+  }
+  serialize(isPublic = true) {
+    const ctor = this.constructor;
+    return ctor.serialize(this, isPublic);
   }
 }
-const e0s = {
-  Default: Error0,
-  Expected: Error0.extend({
-    defaultExpected: true
-  })
-};
 export {
   Error0,
-  e0s
+  ExtensionError0
 };
 //# sourceMappingURL=index.js.map