typetify 0.1.1

package/dist/chunk-JAOGY4JO.mjs

@@ -0,0 +1,1007 @@
+// src/typed/defineConst.ts
+function defineConst(obj) {
+  return Object.freeze(obj);
+}
+
+// src/typed/defineEnum.ts
+function defineEnum(values) {
+  const result = {};
+  for (const value of values) {
+    result[value] = value;
+  }
+  return Object.freeze(result);
+}
+
+// src/typed/defineTuple.ts
+function defineTuple(...args) {
+  return args;
+}
+
+// src/typed/createMap.ts
+function createMap(entries) {
+  return new Map(entries);
+}
+
+// src/typed/createSet.ts
+function createSet(values) {
+  return new Set(values);
+}
+
+// src/typed/brand.ts
+function brand(value) {
+  return value;
+}
+
+// src/typed/narrow.ts
+function narrow(value, guard) {
+  return guard(value) ? value : void 0;
+}
+
+// src/typed/builder.ts
+function createBuilder(initial = {}) {
+  return {
+    set(key, value) {
+      return createBuilder({ ...initial, [key]: value });
+    },
+    build() {
+      return initial;
+    },
+    current() {
+      return initial;
+    }
+  };
+}
+function defineStateMachine(config) {
+  return {
+    config,
+    getInitialState: () => config.initial,
+    transition: (state, event) => {
+      const stateConfig = config.states[state];
+      if (stateConfig && "on" in stateConfig) {
+        const nextState = stateConfig.on[event];
+        return nextState ?? state;
+      }
+      return state;
+    }
+  };
+}
+function createActions() {
+  return new Proxy({}, {
+    get: (_, type) => {
+      return (payload) => ({ type, ...payload });
+    }
+  });
+}
+function createTypedEmitter() {
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    on(event, handler) {
+      if (!listeners.has(event)) {
+        listeners.set(event, /* @__PURE__ */ new Set());
+      }
+      listeners.get(event).add(handler);
+      return () => {
+        listeners.get(event)?.delete(handler);
+      };
+    },
+    emit(event, data) {
+      listeners.get(event)?.forEach((handler) => handler(data));
+    },
+    off(event, handler) {
+      listeners.get(event)?.delete(handler);
+    },
+    clear() {
+      listeners.clear();
+    }
+  };
+}
+function createReducer(initialState, handlers) {
+  return {
+    initialState,
+    reduce: (state, action) => {
+      const handler = handlers[action.type];
+      if (handler) {
+        return handler(state, action);
+      }
+      return state;
+    }
+  };
+}
+
+// src/typed/model.ts
+var STRING_MARKER = /* @__PURE__ */ Symbol("string");
+var NUMBER_MARKER = /* @__PURE__ */ Symbol("number");
+var BOOLEAN_MARKER = /* @__PURE__ */ Symbol("boolean");
+var DATE_MARKER = /* @__PURE__ */ Symbol("date");
+var BIGINT_MARKER = /* @__PURE__ */ Symbol("bigint");
+var SYMBOL_MARKER = /* @__PURE__ */ Symbol("symbol");
+var ANY_MARKER = /* @__PURE__ */ Symbol("any");
+var UNKNOWN_MARKER = /* @__PURE__ */ Symbol("unknown");
+var NULL_MARKER = /* @__PURE__ */ Symbol("null");
+var UNDEFINED_MARKER = /* @__PURE__ */ Symbol("undefined");
+var t = {
+  string: { [STRING_MARKER]: true },
+  number: { [NUMBER_MARKER]: true },
+  boolean: { [BOOLEAN_MARKER]: true },
+  date: { [DATE_MARKER]: true },
+  bigint: { [BIGINT_MARKER]: true },
+  symbol: { [SYMBOL_MARKER]: true },
+  any: { [ANY_MARKER]: true },
+  unknown: { [UNKNOWN_MARKER]: true },
+  null: { [NULL_MARKER]: true },
+  undefined: { [UNDEFINED_MARKER]: true },
+  /** Array of a type */
+  array: (item) => ({ __array: item }),
+  /** Optional field */
+  optional: (type) => ({ __optional: type }),
+  /** Nullable field */
+  nullable: (type) => ({ __nullable: type }),
+  /** Literal value */
+  literal: (value) => ({ __literal: value }),
+  /** Union of literals (enum-like) */
+  enum: (...values) => ({ __enum: values }),
+  /** Union of types */
+  union: (...types) => ({ __union: types }),
+  /** Record/Dictionary */
+  record: (valueType) => ({ __record: valueType }),
+  /** Tuple */
+  tuple: (...types) => ({ __tuple: types }),
+  /** Reference to another model */
+  ref: () => ({ __ref: null })
+};
+function defineModel(definition) {
+  const model2 = {
+    __schema: null,
+    __definition: definition,
+    create(data) {
+      return data;
+    },
+    partial(data) {
+      return data;
+    },
+    is(value) {
+      if (typeof value !== "object" || value === null) return false;
+      for (const key of Object.keys(definition)) {
+        if (!(key in value)) {
+          const fieldDef = definition[key];
+          if (fieldDef && typeof fieldDef === "object" && "__optional" in fieldDef) {
+            continue;
+          }
+          return false;
+        }
+      }
+      return true;
+    },
+    extend(extension) {
+      return defineModel({ ...definition, ...extension });
+    },
+    pick(...keys) {
+      const picked = {};
+      for (const key of keys) {
+        picked[key] = definition[key];
+      }
+      return defineModel(picked);
+    },
+    omit(...keys) {
+      const omitted = { ...definition };
+      for (const key of keys) {
+        delete omitted[key];
+      }
+      return defineModel(omitted);
+    },
+    asPartial() {
+      const partial = {};
+      for (const key of Object.keys(definition)) {
+        partial[key] = { __optional: definition[key] };
+      }
+      return defineModel(partial);
+    },
+    asRequired() {
+      const required = {};
+      for (const key of Object.keys(definition)) {
+        const field = definition[key];
+        if (field && typeof field === "object" && "__optional" in field) {
+          required[key] = field.__optional;
+        } else {
+          required[key] = field;
+        }
+      }
+      return defineModel(required);
+    }
+  };
+  return model2;
+}
+function model(definition) {
+  return defineModel(definition);
+}
+function mergeModels(a, b) {
+  return defineModel({
+    ...a.__definition,
+    ...b.__definition
+  });
+}
+function pickModel(model2, ...keys) {
+  return model2.pick(...keys);
+}
+function omitModel(model2, ...keys) {
+  return model2.omit(...keys);
+}
+
+// src/typed/v.ts
+function createValidator(parser, checker) {
+  const validator = {
+    parse: parser,
+    safeParse(value) {
+      try {
+        return { ok: true, value: parser(value) };
+      } catch (e) {
+        return { ok: false, error: e instanceof Error ? e : new Error(String(e)) };
+      }
+    },
+    is(value) {
+      if (checker) return checker(value);
+      try {
+        parser(value);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    T: void 0,
+    optional() {
+      return createValidator(
+        (val) => val === void 0 ? void 0 : parser(val),
+        (val) => val === void 0 || (checker ? checker(val) : true)
+      );
+    },
+    nullable() {
+      return createValidator(
+        (val) => val === null ? null : parser(val),
+        (val) => val === null || (checker ? checker(val) : true)
+      );
+    },
+    default(defaultValue) {
+      return createValidator(
+        (val) => val === void 0 || val === null ? defaultValue : parser(val)
+      );
+    },
+    transform(fn) {
+      return createValidator((val) => fn(parser(val)));
+    },
+    refine(fn, message = "Validation failed") {
+      return createValidator((val) => {
+        const parsed = parser(val);
+        if (!fn(parsed)) throw new Error(message);
+        return parsed;
+      });
+    }
+  };
+  return validator;
+}
+function stringValidator() {
+  return createValidator(
+    (val) => {
+      if (typeof val !== "string") throw new Error(`Expected string, got ${typeof val}`);
+      return val;
+    },
+    (val) => typeof val === "string"
+  );
+}
+function numberValidator() {
+  return createValidator(
+    (val) => {
+      if (typeof val !== "number" || Number.isNaN(val)) {
+        throw new Error(`Expected number, got ${typeof val}`);
+      }
+      return val;
+    },
+    (val) => typeof val === "number" && !Number.isNaN(val)
+  );
+}
+function booleanValidator() {
+  return createValidator(
+    (val) => {
+      if (typeof val !== "boolean") throw new Error(`Expected boolean, got ${typeof val}`);
+      return val;
+    },
+    (val) => typeof val === "boolean"
+  );
+}
+function dateValidator() {
+  return createValidator(
+    (val) => {
+      if (val instanceof Date) return val;
+      if (typeof val === "string" || typeof val === "number") {
+        const date = new Date(val);
+        if (Number.isNaN(date.getTime())) throw new Error("Invalid date");
+        return date;
+      }
+      throw new Error(`Expected date, got ${typeof val}`);
+    },
+    (val) => val instanceof Date && !Number.isNaN(val.getTime())
+  );
+}
+function literalValidator(value) {
+  return createValidator(
+    (val) => {
+      if (val !== value) throw new Error(`Expected ${String(value)}, got ${String(val)}`);
+      return value;
+    },
+    (val) => val === value
+  );
+}
+function enumValidator(...values) {
+  return createValidator(
+    (val) => {
+      if (!values.includes(val)) {
+        throw new Error(`Expected one of [${values.join(", ")}], got ${String(val)}`);
+      }
+      return val;
+    },
+    (val) => values.includes(val)
+  );
+}
+function emailValidator() {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return stringValidator().refine((val) => emailRegex.test(val), "Invalid email");
+}
+function urlValidator() {
+  return stringValidator().refine((val) => {
+    try {
+      new URL(val);
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Invalid URL");
+}
+function uuidValidator() {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return stringValidator().refine((val) => uuidRegex.test(val), "Invalid UUID");
+}
+function objectValidator(schema) {
+  const base = createValidator(
+    (val) => {
+      if (typeof val !== "object" || val === null) {
+        throw new Error(`Expected object, got ${typeof val}`);
+      }
+      const result = {};
+      const schemaRecord = schema;
+      for (const key of Object.keys(schemaRecord)) {
+        const fieldValidator = schemaRecord[key];
+        if (fieldValidator) {
+          result[key] = fieldValidator.parse(val[key]);
+        }
+      }
+      return result;
+    },
+    (val) => {
+      if (typeof val !== "object" || val === null) return false;
+      const schemaRec = schema;
+      for (const key of Object.keys(schemaRec)) {
+        const fieldVal = schemaRec[key];
+        if (fieldVal && !fieldVal.is(val[key])) return false;
+      }
+      return true;
+    }
+  );
+  const validator = base;
+  validator.schema = schema;
+  validator.pick = (...keys) => {
+    const picked = {};
+    for (const key of keys) picked[key] = schema[key];
+    return objectValidator(picked);
+  };
+  validator.omit = (...keys) => {
+    const omitted = { ...schema };
+    for (const key of keys) delete omitted[key];
+    return objectValidator(omitted);
+  };
+  validator.extend = (ext) => {
+    return objectValidator({ ...schema, ...ext });
+  };
+  validator.partial = () => {
+    const partial = {};
+    const schemaRec = schema;
+    for (const key of Object.keys(schemaRec)) {
+      const fieldVal = schemaRec[key];
+      if (fieldVal) partial[key] = fieldVal.optional();
+    }
+    return objectValidator(partial);
+  };
+  validator.merge = (other) => {
+    return objectValidator({ ...schema, ...other.schema });
+  };
+  return validator;
+}
+function arrayValidator(itemValidator) {
+  return createValidator(
+    (val) => {
+      if (!Array.isArray(val)) throw new Error(`Expected array, got ${typeof val}`);
+      return val.map((item, i) => {
+        try {
+          return itemValidator.parse(item);
+        } catch (e) {
+          throw new Error(`[${i}]: ${e instanceof Error ? e.message : String(e)}`);
+        }
+      });
+    },
+    (val) => Array.isArray(val) && val.every((item) => itemValidator.is(item))
+  );
+}
+function tupleValidator(...validators) {
+  return createValidator(
+    (val) => {
+      if (!Array.isArray(val)) throw new Error(`Expected tuple, got ${typeof val}`);
+      if (val.length !== validators.length) {
+        throw new Error(`Expected ${validators.length} elements, got ${val.length}`);
+      }
+      return validators.map((v2, i) => v2.parse(val[i]));
+    },
+    (val) => Array.isArray(val) && val.length === validators.length && validators.every((v2, i) => v2.is(val[i]))
+  );
+}
+function recordValidator(valueValidator) {
+  return createValidator(
+    (val) => {
+      if (typeof val !== "object" || val === null || Array.isArray(val)) {
+        throw new Error(`Expected record, got ${typeof val}`);
+      }
+      const result = {};
+      for (const [key, value] of Object.entries(val)) {
+        result[key] = valueValidator.parse(value);
+      }
+      return result;
+    },
+    (val) => {
+      if (typeof val !== "object" || val === null || Array.isArray(val)) return false;
+      return Object.values(val).every((v2) => valueValidator.is(v2));
+    }
+  );
+}
+function unionValidator(...validators) {
+  return createValidator(
+    (val) => {
+      for (const v2 of validators) {
+        const result = v2.safeParse(val);
+        if (result.ok) return result.value;
+      }
+      throw new Error("Value does not match any union member");
+    },
+    (val) => validators.some((v2) => v2.is(val))
+  );
+}
+function intersectionValidator(a, b) {
+  return createValidator(
+    (val) => {
+      const parsedA = a.parse(val);
+      const parsedB = b.parse(val);
+      return { ...parsedA, ...parsedB };
+    },
+    (val) => a.is(val) && b.is(val)
+  );
+}
+var v = {
+  // Primitives
+  string: stringValidator,
+  number: numberValidator,
+  boolean: booleanValidator,
+  date: dateValidator,
+  // String refinements
+  email: emailValidator,
+  url: urlValidator,
+  uuid: uuidValidator,
+  // Literals & Enums
+  literal: literalValidator,
+  enum: enumValidator,
+  // Compound types
+  object: objectValidator,
+  array: arrayValidator,
+  tuple: tupleValidator,
+  record: recordValidator,
+  union: unionValidator,
+  intersection: intersectionValidator,
+  // Special
+  any: () => createValidator((val) => val),
+  unknown: () => createValidator((val) => val),
+  null: () => createValidator((val) => {
+    if (val !== null) throw new Error("Expected null");
+    return null;
+  }),
+  undefined: () => createValidator((val) => {
+    if (val !== void 0) throw new Error("Expected undefined");
+    return void 0;
+  })
+};
+
+// src/typed/collection.ts
+var CollectionImpl = class {
+  _items = [];
+  _listeners = /* @__PURE__ */ new Set();
+  get items() {
+    return this._items;
+  }
+  get length() {
+    return this._items.length;
+  }
+  notify() {
+    for (const listener of this._listeners) {
+      listener(this._items);
+    }
+  }
+  add(item) {
+    this._items.push(item);
+    this.notify();
+    return item;
+  }
+  addMany(items) {
+    this._items.push(...items);
+    this.notify();
+    return items;
+  }
+  update(predicate, updates) {
+    const index = this._items.findIndex(predicate);
+    if (index === -1) return void 0;
+    this._items[index] = { ...this._items[index], ...updates };
+    this.notify();
+    return this._items[index];
+  }
+  updateWhere(key, value, updates) {
+    return this.update((item) => item[key] === value, updates);
+  }
+  remove(predicate) {
+    const removed = [];
+    this._items = this._items.filter((item) => {
+      if (predicate(item)) {
+        removed.push(item);
+        return false;
+      }
+      return true;
+    });
+    if (removed.length > 0) this.notify();
+    return removed;
+  }
+  removeWhere(key, value) {
+    const removed = this.remove((item) => item[key] === value);
+    return removed[0];
+  }
+  clear() {
+    this._items = [];
+    this.notify();
+  }
+  findOne(predicate) {
+    return this._items.find(predicate);
+  }
+  find(key, value) {
+    return this._items.find((item) => item[key] === value);
+  }
+  findMany(predicate) {
+    return this._items.filter(predicate);
+  }
+  where(predicate) {
+    return this.findMany(predicate);
+  }
+  whereEquals(key, value) {
+    return this._items.filter((item) => item[key] === value);
+  }
+  some(predicate) {
+    return this._items.some(predicate);
+  }
+  every(predicate) {
+    return this._items.every(predicate);
+  }
+  has(key, value) {
+    return this._items.some((item) => item[key] === value);
+  }
+  first() {
+    return this._items[0];
+  }
+  last() {
+    return this._items[this._items.length - 1];
+  }
+  at(index) {
+    return this._items.at(index);
+  }
+  map(fn) {
+    return this._items.map(fn);
+  }
+  pluck(key) {
+    return this._items.map((item) => item[key]);
+  }
+  pick(...keys) {
+    return this._items.map((item) => {
+      const picked = {};
+      for (const key of keys) {
+        picked[key] = item[key];
+      }
+      return picked;
+    });
+  }
+  omit(...keys) {
+    return this._items.map((item) => {
+      const omitted = { ...item };
+      for (const key of keys) {
+        delete omitted[key];
+      }
+      return omitted;
+    });
+  }
+  sortBy(key, order = "asc") {
+    return [...this._items].sort((a, b) => {
+      const aVal = a[key];
+      const bVal = b[key];
+      if (aVal < bVal) return order === "asc" ? -1 : 1;
+      if (aVal > bVal) return order === "asc" ? 1 : -1;
+      return 0;
+    });
+  }
+  groupBy(key) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const item of this._items) {
+      const groupKey = item[key];
+      const group = groups.get(groupKey) || [];
+      group.push(item);
+      groups.set(groupKey, group);
+    }
+    return groups;
+  }
+  unique(key) {
+    return [...new Set(this._items.map((item) => item[key]))];
+  }
+  count(predicate) {
+    if (!predicate) return this._items.length;
+    return this._items.filter(predicate).length;
+  }
+  subscribe(listener) {
+    this._listeners.add(listener);
+    return () => this._listeners.delete(listener);
+  }
+  toArray() {
+    return [...this._items];
+  }
+  toJSON() {
+    return JSON.stringify(this._items);
+  }
+  fromJSON(json) {
+    this._items = JSON.parse(json);
+    this.notify();
+  }
+};
+var CollectionWithIdImpl = class extends CollectionImpl {
+  constructor(idKey) {
+    super();
+    this.idKey = idKey;
+  }
+  byId(id) {
+    return this.find(this.idKey, id);
+  }
+  updateById(id, updates) {
+    return this.updateWhere(this.idKey, id, updates);
+  }
+  removeById(id) {
+    return this.removeWhere(this.idKey, id);
+  }
+  hasId(id) {
+    return this.has(this.idKey, id);
+  }
+};
+var localStorageAdapter = {
+  async get(key) {
+    if (typeof localStorage === "undefined") return null;
+    return localStorage.getItem(key);
+  },
+  async set(key, value) {
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(key, value);
+  },
+  async remove(key) {
+    if (typeof localStorage === "undefined") return;
+    localStorage.removeItem(key);
+  }
+};
+var PersistentCollectionImpl = class extends CollectionImpl {
+  constructor(storageKey, storage = localStorageAdapter) {
+    super();
+    this.storageKey = storageKey;
+    this.storage = storage;
+  }
+  autoSaveEnabled = false;
+  unsubscribe;
+  async save() {
+    await this.storage.set(this.storageKey, this.toJSON());
+  }
+  async load() {
+    const data = await this.storage.get(this.storageKey);
+    if (data) {
+      this.fromJSON(data);
+    }
+  }
+  enableAutoSave() {
+    if (this.autoSaveEnabled) return;
+    this.autoSaveEnabled = true;
+    this.unsubscribe = this.subscribe(() => {
+      void this.save();
+    });
+  }
+  disableAutoSave() {
+    this.autoSaveEnabled = false;
+    this.unsubscribe?.();
+  }
+};
+function collection(_validator) {
+  return new CollectionImpl();
+}
+function collectionWithId(_validator, idKey) {
+  return new CollectionWithIdImpl(idKey);
+}
+function persistentCollection(_validator, storageKey, storage) {
+  return new PersistentCollectionImpl(storageKey, storage);
+}
+function createCollection(_validator, options) {
+  if (options?.persist) {
+    const col = new PersistentCollectionImpl(options.persist, options.storage);
+    if (options.autoSave) col.enableAutoSave();
+    return col;
+  }
+  if (options?.idKey) {
+    return new CollectionWithIdImpl(options.idKey);
+  }
+  return new CollectionImpl();
+}
+
+// src/typed/states.ts
+function asyncData() {
+  return {
+    idle: () => ({ status: "idle" }),
+    loading: () => ({ status: "loading" }),
+    success: (data) => ({ status: "success", data }),
+    error: (error) => ({ status: "error", error }),
+    isIdle: (state) => state.status === "idle",
+    isLoading: (state) => state.status === "loading",
+    isSuccess: (state) => state.status === "success",
+    isError: (state) => state.status === "error",
+    map: (state, fn) => {
+      if (state.status === "success") {
+        return { status: "success", data: fn(state.data) };
+      }
+      return state;
+    },
+    getOrElse: (state, defaultValue) => {
+      if (state.status === "success") {
+        return state.data;
+      }
+      return defaultValue;
+    }
+  };
+}
+function formState(initialValues) {
+  return {
+    pristine: () => ({ status: "pristine", values: initialValues }),
+    dirty: (values, touched) => ({ status: "dirty", values, touched }),
+    validating: (values) => ({ status: "validating", values }),
+    invalid: (values, errors) => ({ status: "invalid", values, errors }),
+    submitting: (values) => ({ status: "submitting", values }),
+    submitted: (values) => ({ status: "submitted", values }),
+    error: (values, error) => ({ status: "error", values, error }),
+    canSubmit: (state) => state.status === "dirty" || state.status === "pristine",
+    isSubmitting: (state) => state.status === "submitting",
+    hasErrors: (state) => state.status === "invalid"
+  };
+}
+function modalState() {
+  return {
+    closed: () => ({ isOpen: false }),
+    open: (data) => ({ isOpen: true, data }),
+    isOpen: (state) => state.isOpen
+  };
+}
+function undoable(initial) {
+  return {
+    init: () => ({
+      current: initial,
+      past: [],
+      future: [],
+      canUndo: false,
+      canRedo: false
+    }),
+    push: (state, value) => ({
+      current: value,
+      past: [...state.past, state.current],
+      future: [],
+      canUndo: true,
+      canRedo: false
+    }),
+    undo: (state) => {
+      if (state.past.length === 0) return state;
+      const previous = state.past[state.past.length - 1];
+      return {
+        current: previous,
+        past: state.past.slice(0, -1),
+        future: [state.current, ...state.future],
+        canUndo: state.past.length > 1,
+        canRedo: true
+      };
+    },
+    redo: (state) => {
+      if (state.future.length === 0) return state;
+      const next = state.future[0];
+      return {
+        current: next,
+        past: [...state.past, state.current],
+        future: state.future.slice(1),
+        canUndo: true,
+        canRedo: state.future.length > 1
+      };
+    }
+  };
+}
+
+// src/typed/match.ts
+function match(value, discriminant) {
+  return new MatchBuilderImpl(value, discriminant, {});
+}
+var MatchBuilderImpl = class _MatchBuilderImpl {
+  value;
+  discriminant;
+  handlers;
+  result = void 0;
+  matched = false;
+  constructor(value, discriminant, handlers) {
+    this.value = value;
+    this.discriminant = discriminant;
+    this.handlers = handlers;
+  }
+  with(matchValue2, handler) {
+    const newHandlers = { ...this.handlers, [matchValue2]: handler };
+    const builder = new _MatchBuilderImpl(this.value, this.discriminant, newHandlers);
+    const discriminantValue = this.value[this.discriminant];
+    if (!this.matched && discriminantValue === matchValue2) {
+      builder.result = handler(this.value);
+      builder.matched = true;
+    } else {
+      builder.result = this.result;
+      builder.matched = this.matched;
+    }
+    return builder;
+  }
+  exhaustive() {
+    if (this.matched) {
+      return this.result;
+    }
+    throw new Error(`No handler matched for discriminant value: ${String(this.value[this.discriminant])}`);
+  }
+  otherwise(handler) {
+    if (this.matched) {
+      return this.result;
+    }
+    return handler(this.value);
+  }
+  run() {
+    return this.exhaustive();
+  }
+};
+function matchValue(value, cases) {
+  const handler = cases[value];
+  if (!handler) {
+    throw new Error(`No handler for value: ${String(value)}`);
+  }
+  return handler();
+}
+function matchUnion(value, discriminant, handlers) {
+  const discriminantValue = value[discriminant];
+  const handler = handlers[discriminantValue];
+  return handler(value);
+}
+function createMatcher() {
+  return (discriminant) => {
+    return (value, handlers) => {
+      return matchUnion(value, discriminant, handlers);
+    };
+  };
+}
+
+// src/typed/debug.ts
+function showType(_value) {
+  return _value;
+}
+function assertType(_value) {
+}
+function impossible(value) {
+  throw new Error(`Unexpected value: ${JSON.stringify(value)}`);
+}
+function identity(value) {
+  return value;
+}
+function narrow2(guard) {
+  return guard;
+}
+
+// src/typed/merge.ts
+function merge(a, b) {
+  return { ...a, ...b };
+}
+function mergeAll(...objects) {
+  return Object.assign({}, ...objects);
+}
+function deepMerge(a, b) {
+  const result = { ...a };
+  for (const key of Object.keys(b)) {
+    const bValue = b[key];
+    const aValue = a[key];
+    if (isPlainObject(bValue) && isPlainObject(aValue)) {
+      result[key] = deepMerge(
+        aValue,
+        bValue
+      );
+    } else {
+      result[key] = bValue;
+    }
+  }
+  return result;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function mergeWith(a, b, resolvers) {
+  const result = { ...a, ...b };
+  for (const key of Object.keys(resolvers)) {
+    const resolver = resolvers[key];
+    if (resolver && key in a && key in b) {
+      result[key] = resolver(
+        a[key],
+        b[key]
+      );
+    }
+  }
+  return result;
+}
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+function renameKeys(obj, mapping) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const newKey = mapping[key];
+    if (newKey !== void 0) {
+      result[newKey] = obj[key];
+    } else {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function fromEntries(entries) {
+  return Object.fromEntries(entries);
+}
+function mapValues(obj, fn) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[key] = fn(obj[key], key);
+  }
+  return result;
+}
+function mapKeys(obj, fn) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const newKey = fn(key);
+    result[newKey] = obj[key];
+  }
+  return result;
+}
+
+export { assertType, asyncData, brand, collection, collectionWithId, createActions, createBuilder, createCollection, createMap, createMatcher, createReducer, createSet, createTypedEmitter, deepMerge, defineConst, defineEnum, defineModel, defineStateMachine, defineTuple, formState, fromEntries, identity, impossible, mapKeys, mapValues, match, matchUnion, matchValue, merge, mergeAll, mergeModels, mergeWith, modalState, model, narrow, narrow2, omit, omitModel, persistentCollection, pick, pickModel, renameKeys, showType, t, undoable, v };
+//# sourceMappingURL=chunk-JAOGY4JO.mjs.map
+//# sourceMappingURL=chunk-JAOGY4JO.mjs.map