perlica/dist/cjs/index.cjs

<h1 align="center">Perlica</h1>

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all2) => {
  for (var name in all2)
    __defProp(target, name, { get: all2[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  Iterator: () => Iterator_exports,
  Option: () => Option_exports,
  Predicate: () => Predicate_exports,
  Result: () => Result_exports,
  Task: () => Task_exports
});
module.exports = __toCommonJS(index_exports);

// src/Result.ts
var Result_exports = {};
__export(Result_exports, {
  ResultProto: () => ResultProto,
  and: () => and2,
  andThen: () => andThen,
  bind: () => bind2,
  err: () => err,
  expect: () => expect,
  expectErr: () => expectErr,
  fromNullable: () => fromNullable2,
  fromOption: () => fromOption,
  isErr: () => isErr,
  isOk: () => isOk,
  ok: () => ok,
  tryCatch: () => tryCatch2,
  tryPromise: () => tryPromise2,
  unwrap: () => unwrap,
  unwrapErr: () => unwrapErr,
  unwrapOr: () => unwrapOr,
  unwrapOrElse: () => unwrapOrElse
});

// src/Iterator.ts
var Iterator_exports = {};
__export(Iterator_exports, {
  OnceIterator: () => OnceIterator
});
var OnceIterator = class _OnceIterator {
  constructor(value) {
    this.value = value;
  }
  done = false;
  next(value) {
    if (this.done) {
      return {
        done: true,
        value
      };
    }
    this.done = true;
    return {
      done: false,
      value: this.value
    };
  }
  [Symbol.iterator]() {
    return new _OnceIterator(this.value);
  }
};

// src/Predicate/index.ts
var Predicate_exports = {};
__export(Predicate_exports, {
  all: () => all,
  and: () => and,
  any: () => any,
  eq: () => eq,
  hasProperty: () => hasProperty,
  isArray: () => isArray,
  isAsyncIterable: () => isAsyncIterable,
  isBigInt: () => isBigInt,
  isBoolean: () => isBoolean,
  isDate: () => isDate,
  isError: () => isError,
  isFunction: () => isFunction,
  isInteger: () => isInteger,
  isIterable: () => isIterable,
  isMap: () => isMap,
  isNotNull: () => isNotNull,
  isNotNullable: () => isNotNullable,
  isNotUndefined: () => isNotUndefined,
  isNull: () => isNull,
  isNullable: () => isNullable,
  isNumber: () => isNumber,
  isObject: () => isObject,
  isPromise: () => isPromise,
  isRecordOrArray: () => isRecordOrArray,
  isRegExp: () => isRegExp,
  isSet: () => isSet,
  isString: () => isString,
  isSymbol: () => isSymbol,
  isTruthy: () => isTruthy,
  isUndefined: () => isUndefined,
  ne: () => ne,
  not: () => not,
  or: () => or
});
var not = (self) => (value) => !self(value);
var and = (self, that) => (value) => self(value) && that(value);
var or = (self, that) => (value) => self(value) || that(value);
var all = (predicates) => {
  return (value) => {
    for (const p of predicates) {
      if (p(value) === false) {
        return false;
      }
    }
    return true;
  };
};
var any = (predicates) => {
  return (value) => {
    for (const p of predicates) {
      if (p(value) === true) {
        return true;
      }
    }
    return false;
  };
};
var eq = (that) => (value) => value === that;
var ne = (that) => (value) => value !== that;
var isTruthy = (value) => !!value;
var isNull = (value) => value === null;
var isNotNull = (value) => value !== null;
var isUndefined = (value) => value === void 0;
var isNotUndefined = (value) => value !== void 0;
var isBoolean = (value) => typeof value === "boolean";
var isNumber = (value) => typeof value === "number";
var isInteger = (value) => Number.isInteger(value);
var isBigInt = (value) => typeof value === "bigint";
var isString = (value) => typeof value === "string";
var isArray = (value) => Array.isArray(value);
var isFunction = (value) => typeof value === "function";
var isSymbol = (value) => typeof value === "symbol";
var isSet = (value) => value instanceof Set;
var isMap = (value) => value instanceof Map;
var isRegExp = (value) => value instanceof RegExp;
var isError = (value) => value instanceof Error;
var isNullable = (value) => isNull(value) || isUndefined(value);
var isNotNullable = (value) => isNotNull(value) && isNotUndefined(value);
var isPromise = (value) => hasProperty(value, "then") && hasProperty(value, "catch") && isFunction(value.then) && isFunction(value.catch);
var isDate = (value) => value instanceof Date;
var isRecordOrArray = (value) => typeof value === "object" && isNotNull(value);
var isObject = (value) => isRecordOrArray(value) || isFunction(value);
var hasProperty = (value, property) => isObject(value) && property in value;
var isIterable = (value) => hasProperty(value, Symbol.iterator);
var isAsyncIterable = (value) => hasProperty(value, Symbol.asyncIterator);

// src/Option.ts
var Option_exports = {};
__export(Option_exports, {
  OptionProto: () => OptionProto,
  bind: () => bind,
  fromNullable: () => fromNullable,
  fromResult: () => fromResult,
  isNone: () => isNone,
  isSome: () => isSome,
  none: () => none,
  some: () => some,
  tryCatch: () => tryCatch,
  tryPromise: () => tryPromise
});
var isSome = (r) => r.tag === "some";
var isNone = (r) => r.tag === "none";
var OptionProto = () => ({
  and(v) {
    return isSome(this) ? v : none();
  },
  andThen(f) {
    return isSome(this) ? f(this.value) : none();
  },
  expect(msg) {
    if (isSome(this)) {
      return this.value;
    } else {
      throw new Error(msg);
    }
  },
  filter(f) {
    return isNone(this) ? none() : f(this.value) ? this : none();
  },
  flatten() {
    return isSome(this) ? this.value : none();
  },
  inspect(f) {
    if (isSome(this)) {
      f(this.value);
      return some(this.value);
    } else {
      return none();
    }
  },
  isNone() {
    return isNone(this);
  },
  isNoneOr(f) {
    return isNone(this) || f(this.value);
  },
  isSome() {
    return isSome(this);
  },
  isSomeAnd(f) {
    return isNone(this) ? false : f(this.value);
  },
  map(f) {
    return isSome(this) ? some(f(this.value)) : none();
  },
  mapOr(def, f) {
    return isSome(this) ? f(this.value) : def;
  },
  mapOrElse(d, f) {
    return isSome(this) ? f(this.value) : d();
  },
  okOr(v) {
    return isSome(this) ? ok(this.value) : err(v);
  },
  okOrElse(f) {
    return isSome(this) ? ok(this.value) : err(f());
  },
  or(v) {
    return isSome(this) ? this : v;
  },
  orElse(f) {
    return isSome(this) ? this : f();
  },
  transpose() {
    return isNone(this) ? ok(none()) : isErr(this.value) ? err(this.value.value) : ok(some(this.value.value));
  },
  unwrap() {
    if (isSome(this)) {
      return this.value;
    } else {
      throw new Error("called `Option.unwrap()` on a `None` value");
    }
  },
  unwrapOr(def) {
    return isSome(this) ? this.value : def;
  },
  unwrapOrElse(def) {
    return isSome(this) ? this.value : def();
  },
  xor(v) {
    return isSome(this) && isSome(v) ? this : isNone(this) && isSome(v) ? v : none();
  },
  [Symbol.iterator]() {
    return new OnceIterator(this);
  }
});
var fromNullable = (v) => isNotNullable(v) ? some(v) : none();
var fromResult = (v) => v.ok();
var tryCatch = (f) => {
  try {
    return some(f());
  } catch (_) {
    return none();
  }
};
var tryPromise = async (v) => v.then((s) => some(s)).catch((_) => none());
var some = (v) => {
  const a = Object.create(OptionProto());
  a.value = v;
  a.tag = "some";
  return a;
};
var none = () => {
  const a = Object.create(OptionProto());
  a.tag = "none";
  return a;
};
var bind = (fn) => {
  const iter = fn();
  let result = iter.next();
  while (true) {
    if (result.done) {
      return some(result.value);
    }
    if (isSome(result.value)) {
      result = iter.next(result.value.value);
    } else {
      return result.value;
    }
  }
};

// src/Result.ts
var and2 = (self, that) => self.and(that);
var andThen = (self, f) => self.andThen(f);
var expect = (self, msg) => self.expect(msg);
var expectErr = (self, msg) => self.expectErr(msg);
var isOk = (r) => r.tag === "ok";
var isErr = (r) => r.tag === "err";
var unwrap = (self) => self.unwrap();
var unwrapErr = (self) => self.unwrapErr();
var unwrapOr = (self, def) => self.unwrapOr(def);
var unwrapOrElse = (self, def) => self.unwrapOrElse(def);
var fromNullable2 = (v, f) => isNotNullable(v) ? ok(v) : err(f());
var fromOption = (self, f) => self.okOr(f());
var tryCatch2 = (f) => {
  try {
    return ok(f());
  } catch (e) {
    return err(e);
  }
};
var tryPromise2 = async (v) => v.then((s) => ok(s)).catch((f) => err(f));
var bind2 = (fn) => {
  const iter = fn();
  let result = iter.next();
  while (true) {
    if (result.done) {
      return ok(result.value);
    }
    if (isOk(result.value)) {
      result = iter.next(result.value.value);
    } else {
      return result.value;
    }
  }
};
var ok = (v) => {
  const a = Object.create(ResultProto());
  a.value = v;
  a.tag = "ok";
  return a;
};
var err = (v) => {
  const a = Object.create(ResultProto());
  a.value = v;
  a.tag = "err";
  return a;
};
var ResultProto = () => ({
  and(res) {
    return isOk(this) ? res : err(this.value);
  },
  andThen(f) {
    return isOk(this) ? f(this.value) : err(this.value);
  },
  err() {
    return isErr(this) ? some(this.value) : none();
  },
  expect(msg) {
    if (isOk(this)) {
      return this.value;
    } else {
      throw new Error(msg);
    }
  },
  expectErr(msg) {
    if (isErr(this)) {
      return this.value;
    } else {
      throw new Error(msg);
    }
  },
  flatten() {
    return this.andThen((v) => v);
  },
  inspect(f) {
    if (isOk(this)) {
      f(this.value);
      return ok(this.value);
    } else {
      return err(this.value);
    }
  },
  inspectErr(f) {
    if (isErr(this)) {
      f(this.value);
      return err(this.value);
    } else {
      return ok(this.value);
    }
  },
  isErr() {
    return isErr(this);
  },
  isErrAnd(f) {
    return isErr(this) && f(this.value);
  },
  isOk() {
    return isOk(this);
  },
  isOkAnd(f) {
    return isOk(this) && f(this.value);
  },
  map(f) {
    return isOk(this) ? ok(f(this.value)) : err(this.value);
  },
  mapErr(f) {
    return isErr(this) ? err(f(this.value)) : ok(this.value);
  },
  mapOr(def, f) {
    return isOk(this) ? f(this.value) : def;
  },
  mapOrElse(def, f) {
    return isOk(this) ? f(this.value) : def(this.value);
  },
  ok() {
    return isOk(this) ? some(this.value) : none();
  },
  or(f) {
    return isErr(this) ? err(f(this.value)) : ok(this.value);
  },
  orElse(f) {
    return isErr(this) ? f(this.value) : ok(this.value);
  },
  transpose() {
    return isErr(this) ? some(err(this.value)) : isNone(this.value) ? none() : some(ok(this.value.value));
  },
  unwrap() {
    if (isOk(this)) {
      return this.value;
    } else {
      throw new Error(`called \`Result.unwrap()\` on an \`Err\` value: ${String(this.value)}`);
    }
  },
  unwrapErr() {
    if (isErr(this)) {
      return this.value;
    } else {
      throw new Error(`called \`Result.unwrapErr()\` on an \`Ok\` value: ${String(this.value)}`);
    }
  },
  unwrapOr(def) {
    return isOk(this) ? this.value : def;
  },
  unwrapOrElse(def) {
    return isOk(this) ? this.value : def(this.value);
  },
  [Symbol.iterator]() {
    return new OnceIterator(this);
  }
});

// src/Task/index.ts
var Task_exports = {};
__export(Task_exports, {
  Task: () => Task,
  and: () => and3,
  bind: () => bind3,
  createTask: () => createTask,
  expect: () => expect2,
  filter: () => filter,
  flatMap: () => flatMap,
  flatten: () => flatten,
  inspect: () => inspect,
  map: () => map,
  mapOr: () => mapOr,
  mapOrElse: () => mapOrElse,
  of: () => of,
  okOr: () => okOr,
  okOrElse: () => okOrElse,
  or: () => or2,
  orElse: () => orElse,
  safeRun: () => safeRun,
  toResult: () => toResult,
  unwrap: () => unwrap2,
  unwrapOr: () => unwrapOr2,
  unwrapOrElse: () => unwrapOrElse2
});

// src/Task/Task.ts
var Task = class {
  constructor(f) {
    this.f = f;
  }
  unsafeRun() {
    return this.f();
  }
  map(f) {
    return map(f)(this);
  }
  flatMap(f) {
    return flatMap(f)(this);
  }
  filter(predicate) {
    return filter(predicate)(this);
  }
  and(that) {
    return and3(that)(this);
  }
  expect(msg) {
    return expect2(msg)(this);
  }
  inspect(f) {
    return inspect(f)(this);
  }
  mapOr(def, f) {
    return mapOr(def, f)(this);
  }
  mapOrElse(d, f) {
    return mapOrElse(d, f)(this);
  }
  okOr(error) {
    return okOr(error)(this);
  }
  okOrElse(f) {
    return okOrElse(f)(this);
  }
  or(that) {
    return or2(that)(this);
  }
  orElse(f) {
    return orElse(f)(this);
  }
  unwrap() {
    return unwrap2(this);
  }
  unwrapOr(def) {
    return unwrapOr2(def)(this);
  }
  unwrapOrElse(f) {
    return unwrapOrElse2(f)(this);
  }
  safeRun() {
    return safeRun(this);
  }
  [Symbol.iterator]() {
    return new OnceIterator(this);
  }
};
var createTask = (f) => {
  return new Task(f);
};

// src/Task/functions.ts
var of = (value) => createTask(async () => value);
var map = (f) => (task) => {
  return createTask(async () => {
    const a = await task.unsafeRun();
    return f(a);
  });
};
var flatMap = (f) => (task) => {
  return createTask(async () => {
    const a = await task.unsafeRun();
    const b = f(a);
    return await b.unsafeRun();
  });
};
var flatten = (task) => {
  return createTask(async () => {
    const inner = await task.unsafeRun();
    return await inner.unsafeRun();
  });
};
var okOr = (error) => (task) => {
  return createTask(async () => {
    try {
      const v = await task.unsafeRun();
      return ok(v);
    } catch {
      return err(error);
    }
  });
};
var okOrElse = (f) => (task) => {
  return createTask(async () => {
    try {
      const v = await task.unsafeRun();
      return ok(v);
    } catch {
      return err(f());
    }
  });
};
var and3 = (that) => (task) => {
  return createTask(async () => {
    await task.unsafeRun();
    return await that.unsafeRun();
  });
};
var expect2 = (msg) => (task) => {
  return createTask(async () => {
    const v = await task.unsafeRun();
    if (v === null || v === void 0) {
      throw new Error(msg);
    }
    return v;
  });
};
var filter = (f) => (task) => {
  return createTask(async () => {
    const v = await task.unsafeRun();
    return f(v) ? some(v) : none();
  });
};
var inspect = (f) => (task) => {
  return createTask(async () => {
    const v = await task.unsafeRun();
    f(v);
    return v;
  });
};
var mapOr = (def, f) => (task) => {
  return createTask(async () => {
    try {
      const a = await task.unsafeRun();
      return f(a);
    } catch {
      return def;
    }
  });
};
var mapOrElse = (d, f) => (task) => {
  return createTask(async () => {
    try {
      const a = await task.unsafeRun();
      return f(a);
    } catch {
      return d();
    }
  });
};
var or2 = (that) => (task) => {
  return createTask(async () => {
    try {
      return await task.unsafeRun();
    } catch {
      return await that.unsafeRun();
    }
  });
};
var orElse = (f) => (task) => {
  return createTask(async () => {
    try {
      return await task.unsafeRun();
    } catch {
      return await f().unsafeRun();
    }
  });
};
var unwrap2 = (task) => {
  return createTask(async () => {
    const v = await task.unsafeRun();
    if (v === null || v === void 0) {
      throw new Error(`called \`Task.unwrap()\` on a null value`);
    }
    return v;
  });
};
var unwrapOr2 = (def) => (task) => {
  return createTask(async () => {
    try {
      const a = await task.unsafeRun();
      return a;
    } catch {
      return def;
    }
  });
};
var unwrapOrElse2 = (f) => (task) => {
  return createTask(async () => {
    try {
      const a = await task.unsafeRun();
      return a;
    } catch {
      return f();
    }
  });
};
var toResult = (task) => {
  return createTask(async () => {
    try {
      const v = await task.unsafeRun();
      return ok(v);
    } catch (e) {
      return err(e);
    }
  });
};
var safeRun = async (task) => {
  try {
    const v = await task.unsafeRun();
    return ok(v);
  } catch (e) {
    return err(e);
  }
};
var bind3 = (fn) => {
  return createTask(async () => {
    const iter = fn();
    let result = iter.next();
    while (true) {
      if (result.done) {
        return result.value;
      }
      result = await result.value.map((t) => iter.next(t)).unsafeRun();
    }
  });
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  Iterator,
  Option,
  Predicate,
  Result,
  Task
});