@shwfed/config 1.1.5 → 2.0.0

package/dist/runtime/vendor/cel-js/lib/optional.js

@@ -1,111 +0,0 @@
-import { Effect, Option } from "effect";
-import { evaluationError } from "./errors.js";
-export function optionalOf(value) {
-  return value === void 0 ? Option.none() : Option.some(value);
-}
-export function optionalValue(opt) {
-  if (Option.isNone(opt)) {
-    throw evaluationError("optional_value_missing", "Optional value is not present");
-  }
-  return opt.value;
-}
-class OptionalNamespace {
-  #kind = "optional";
-  toString() {
-    return this.#kind;
-  }
-}
-const optionalNamespace = new OptionalNamespace();
-export function register(registry) {
-  const functionOverload = (sig, handler) => registry.registerFunctionOverload(sig, handler);
-  registry.registerType("OptionalNamespace", OptionalNamespace);
-  registry.registerConstant("optional", "OptionalNamespace", optionalNamespace);
-  functionOverload("optional.hasValue(): bool", (v) => Option.isSome(v));
-  functionOverload("optional<A>.value(): A", (v) => optionalValue(v));
-  registry.registerFunctionOverload("OptionalNamespace.none(): optional<T>", () => Option.none());
-  functionOverload("OptionalNamespace.of(A): optional<A>", (_, value) => optionalOf(value));
-  function ensureOptional(value, ast, description) {
-    if (Option.isOption(value)) return value;
-    throw evaluationError("optional_expected", `${description} must be optional`, ast);
-  }
-  function evaluateOptional(ev, macro, ctx) {
-    return Effect.gen(function* () {
-      const v = yield* ev.eval(macro.receiver, ctx);
-      const optional = ensureOptional(v, macro.receiver, `${macro.functionDesc} receiver`);
-      if (Option.isSome(optional)) return macro.onHasValue(optional);
-      return yield* macro.onEmpty(ev, macro, ctx);
-    });
-  }
-  function ensureOptionalType(checker, node, ctx, description) {
-    const type = checker.check(node, ctx);
-    if (type.kind === "optional") return type;
-    if (type.kind === "dyn") return checker.getType("optional");
-    throw checker.createError("optional_expected", `${description} must be optional, got '${type}'`, node);
-  }
-  function createOptionalMacro({ functionDesc, evaluate, typeCheck, onHasValue, onEmpty }) {
-    return (opts) => {
-      const { ast, args, receiver } = opts;
-      return {
-        ast,
-        functionDesc,
-        receiver,
-        arg: args[0],
-        evaluate,
-        typeCheck,
-        onHasValue,
-        onEmpty
-      };
-    };
-  }
-  const invalidOrValueReceiver = "optional.orValue() receiver";
-  const invalidOrReceiver = "optional.or(optional) receiver";
-  const invalidOrArg = "optional.or(optional) argument";
-  registry.registerFunctionOverload(
-    "optional.or(ast): optional<dyn>",
-    createOptionalMacro({
-      functionDesc: "optional.or(optional)",
-      evaluate: evaluateOptional,
-      typeCheck(check, macro, ctx) {
-        const l = ensureOptionalType(check, macro.receiver, ctx, invalidOrReceiver);
-        const r = ensureOptionalType(check, macro.arg, ctx, invalidOrArg);
-        const unified = l.unify(check.registry, r);
-        if (unified) return unified;
-        throw check.createError(
-          "incompatible_argument_type",
-          `${macro.functionDesc} argument must be compatible type, got '${l}' and '${r}'`,
-          macro.arg
-        );
-      },
-      onHasValue: (optional) => optional,
-      onEmpty(ev, macro, ctx) {
-        const ast = macro.arg;
-        return ev.eval(ast, ctx).pipe(
-          Effect.map((v) => ensureOptional(v, ast, invalidOrArg))
-        );
-      }
-    })
-  );
-  registry.registerFunctionOverload(
-    "optional.orValue(ast): dyn",
-    createOptionalMacro({
-      functionDesc: "optional.orValue(value)",
-      onHasValue: (opt) => opt.value,
-      onEmpty(ev, macro, ctx) {
-        return ev.eval(macro.arg, ctx);
-      },
-      evaluate: evaluateOptional,
-      typeCheck(check, macro, ctx) {
-        const l = ensureOptionalType(check, macro.receiver, ctx, invalidOrValueReceiver).valueType;
-        const r = check.check(macro.arg, ctx);
-        if (!l) return r;
-        const unified = l.unify(check.registry, r);
-        if (unified) return unified;
-        throw check.createError(
-          "incompatible_argument_type",
-          `${macro.functionDesc} argument must be compatible type, got '${l}' and '${r}'`,
-          macro.arg
-        );
-      }
-    })
-  );
-}

package/dist/runtime/vendor/cel-js/lib/options.d.ts

@@ -1,15 +0,0 @@
-export interface Limits {
-    maxAstNodes: number;
-    maxDepth: number;
-    maxListElements: number;
-    maxMapEntries: number;
-    maxCallArguments: number;
-}
-export interface ResolvedOptions {
-    unlistedVariablesAreDyn: boolean;
-    limits: Limits;
-}
-export declare function createOptions(opts?: {
-    unlistedVariablesAreDyn?: boolean;
-    limits?: Partial<Limits>;
-} | null, base?: Readonly<ResolvedOptions>): Readonly<ResolvedOptions>;

package/dist/runtime/vendor/cel-js/lib/options.js

@@ -1,37 +0,0 @@
-import { objFreeze, objKeys } from "./globals.js";
-const DEFAULT_LIMITS = objFreeze({
-  maxAstNodes: 1e5,
-  maxDepth: 250,
-  maxListElements: 1e3,
-  maxMapEntries: 1e3,
-  maxCallArguments: 32
-});
-const LIMIT_KEYS = new Set(objKeys(DEFAULT_LIMITS));
-function createLimits(overrides, base = DEFAULT_LIMITS) {
-  const keys = overrides ? objKeys(overrides) : void 0;
-  if (!keys?.length) return base;
-  const merged = { ...base };
-  for (const key of keys) {
-    if (!LIMIT_KEYS.has(key)) throw new TypeError(`Unknown limits option: ${key}`);
-    const value = overrides[key];
-    if (typeof value !== "number") continue;
-    merged[key] = value;
-  }
-  return objFreeze(merged);
-}
-const DEFAULT_OPTIONS = objFreeze({
-  unlistedVariablesAreDyn: false,
-  limits: DEFAULT_LIMITS
-});
-function bool(a, b, key) {
-  const value = a?.[key] ?? b?.[key];
-  if (typeof value !== "boolean") throw new TypeError(`Invalid option: ${key}`);
-  return value;
-}
-export function createOptions(opts, base = DEFAULT_OPTIONS) {
-  if (!opts) return base;
-  return objFreeze({
-    unlistedVariablesAreDyn: bool(opts, base, "unlistedVariablesAreDyn"),
-    limits: createLimits(opts.limits, base.limits)
-  });
-}

package/dist/runtime/vendor/cel-js/lib/overloads.d.ts

@@ -1,2 +0,0 @@
-import type { Registry } from './registry.js.js';
-export declare function registerOverloads(registry: Registry): void;

package/dist/runtime/vendor/cel-js/lib/overloads.js

@@ -1,170 +0,0 @@
-import { Decimal } from "./decimal.js";
-import { evaluationError } from "./errors.js";
-import { isArray, hasOwn, objKeys } from "./globals.js";
-import { isBefore, isAfter, isEqual as isDateEqual } from "date-fns";
-export function registerOverloads(registry) {
-  const unaryOverload = (op, t, h, ret) => registry.unaryOverload(op, t, h, ret, false);
-  const binaryOverload = (l, op, r, h, ret) => registry.binaryOverload(l, op, r, h, ret, false);
-  function throwDivisionByZero(ast) {
-    throw evaluationError("division_by_zero", "division by zero", ast);
-  }
-  function throwModuloByZero(ast) {
-    throw evaluationError("modulo_by_zero", "modulo by zero", ast);
-  }
-  unaryOverload("!", "bool", (a) => !a);
-  unaryOverload("-", "number", (a) => Decimal.from(a).neg());
-  binaryOverload("number", "*", "number", (a, b) => Decimal.from(a).mul(b));
-  binaryOverload("number", "+", "number", (a, b) => Decimal.from(a).add(b));
-  binaryOverload("number", "-", "number", (a, b) => Decimal.from(a).sub(b));
-  binaryOverload("number", "/", "number", (a, b, ast) => {
-    const bd = Decimal.from(b);
-    if (bd.isZero()) return throwDivisionByZero(ast);
-    return Decimal.from(a).div(bd);
-  });
-  binaryOverload("number", "%", "number", (a, b, ast) => {
-    const bd = Decimal.from(b);
-    if (bd.isZero()) return throwModuloByZero(ast);
-    return Decimal.from(a).mod(bd);
-  });
-  binaryOverload("string", "+", "string", (a, b) => a + b);
-  binaryOverload("list<V>", "+", "list<V>", (a, b) => [...a, ...b]);
-  binaryOverload("bytes", "+", "bytes", (a, b) => {
-    const ab = a;
-    const bb = b;
-    if (!ab.length) return bb;
-    if (!bb.length) return ab;
-    const result = new Uint8Array(ab.length + bb.length);
-    result.set(ab, 0);
-    result.set(bb, ab.length);
-    return result;
-  });
-  binaryOverload("Date", "==", "Date", (a, b) => isDateEqual(a, b));
-  binaryOverload("Date", "<", "Date", (a, b) => isBefore(a, b));
-  binaryOverload("Date", "<=", "Date", (a, b) => !isAfter(a, b));
-  binaryOverload("Date", ">", "Date", (a, b) => isAfter(a, b));
-  binaryOverload("Date", ">=", "Date", (a, b) => !isBefore(a, b));
-  function listIncludes(value, list, ast, ev) {
-    const listVal = list;
-    if (listVal instanceof Set && listVal.has(value)) return true;
-    for (const v of listVal) if (isEqual(value, v, ast, ev)) return true;
-    return false;
-  }
-  function mapIncludes(a, b) {
-    const bMap = b;
-    if (bMap instanceof Map) return bMap.get(a) !== void 0;
-    return hasOwn(bMap, a) ? bMap[a] !== void 0 : false;
-  }
-  function listMembership(value, list, ast, ev) {
-    return listIncludes(value, list, ast, ev);
-  }
-  binaryOverload("V", "in", "list<V>", listMembership);
-  binaryOverload("K", "in", "map<K, V>", mapIncludes);
-  for (const t of ["type", "null", "bool", "string"]) {
-    binaryOverload(t, "==", t, (a, b) => a === b);
-  }
-  binaryOverload("number", "==", "number", (a, b) => Decimal.from(a).eq(b));
-  binaryOverload("bytes", `==`, "bytes", (a, b) => {
-    if (a === b) return true;
-    const ab = a;
-    const bb = b;
-    let i = ab.length;
-    if (i !== bb.length) return false;
-    while (i--) if (ab[i] !== bb[i]) return false;
-    return true;
-  });
-  binaryOverload("list<V>", `==`, "list<V>", (a, b, ast, ev) => {
-    if (a === b) return true;
-    if (isArray(a) && isArray(b)) {
-      const arr1 = a;
-      const arr2 = b;
-      const length = arr1.length;
-      if (length !== arr2.length) return false;
-      for (let i = 0; i < length; i++) {
-        if (!isEqual(arr1[i], arr2[i], ast, ev)) return false;
-      }
-      return true;
-    }
-    if (a instanceof Set && b instanceof Set) {
-      if (a.size !== b.size) return false;
-      for (const value of a) if (!b.has(value)) return false;
-      return true;
-    }
-    const arr = a instanceof Set ? b : a;
-    const set = a instanceof Set ? a : b;
-    if (!isArray(arr)) return false;
-    const arrTyped = arr;
-    const setTyped = set;
-    if (arrTyped.length !== setTyped?.size) return false;
-    for (let i = 0; i < arrTyped.length; i++) if (!setTyped.has(arrTyped[i])) return false;
-    return true;
-  });
-  binaryOverload("map<K, V>", `==`, "map<K, V>", (a, b, ast, ev) => {
-    if (a === b) return true;
-    if (a instanceof Map && b instanceof Map) {
-      if (a.size !== b.size) return false;
-      for (const [key, value] of a)
-        if (!(b.has(key) && isEqual(value, b.get(key), ast, ev))) return false;
-      return true;
-    }
-    if (a instanceof Map || b instanceof Map) {
-      const obj = a instanceof Map ? b : a;
-      const map = a instanceof Map ? a : b;
-      const keysObj = objKeys(obj);
-      if (map.size !== keysObj.length) return false;
-      for (const [key, value] of map) {
-        if (!(key in obj && isEqual(value, obj[key], ast, ev))) return false;
-      }
-      return true;
-    }
-    const ao = a;
-    const bo = b;
-    const keysA = objKeys(ao);
-    const keysB = objKeys(bo);
-    if (keysA.length !== keysB.length) return false;
-    for (let i = 0; i < keysA.length; i++) {
-      const key = keysA[i];
-      if (!(key in bo && isEqual(ao[key], bo[key], ast, ev))) return false;
-    }
-    return true;
-  });
-  for (const [left, right] of [
-    ["bool", "bool"],
-    ["number", "number"],
-    ["string", "string"]
-  ]) {
-    const isNum = left === "number";
-    binaryOverload(left, "<", right, isNum ? (a, b) => Decimal.from(a).lt(b) : (a, b) => a < b);
-    binaryOverload(left, "<=", right, isNum ? (a, b) => Decimal.from(a).lte(b) : (a, b) => a <= b);
-    binaryOverload(left, ">", right, isNum ? (a, b) => Decimal.from(a).gt(b) : (a, b) => a > b);
-    binaryOverload(left, ">=", right, isNum ? (a, b) => Decimal.from(a).gte(b) : (a, b) => a >= b);
-  }
-}
-function isEqual(a, b, ast, ev) {
-  if (a === b) return true;
-  switch (typeof a) {
-    case "undefined":
-    case "string":
-    case "boolean":
-      return false;
-    case "number":
-    case "bigint":
-      if (typeof b === "number" || typeof b === "bigint" || b instanceof Decimal)
-        return Decimal.from(a).eq(b);
-      return false;
-    case "object": {
-      if (a instanceof Decimal) {
-        if (b instanceof Decimal || typeof b === "number" || typeof b === "bigint")
-          return a.eq(b);
-        return false;
-      }
-      if (typeof b !== "object") return false;
-      const leftType = ev.debugType(a);
-      const rightType = ev.debugType(b);
-      if (leftType !== rightType) return false;
-      const overload = ev.registry.findBinaryOverload("==", leftType, rightType);
-      if (!overload) return false;
-      return overload.handler(a, b, ast, ev);
-    }
-  }
-  throw evaluationError("invalid_comparison_type", `Cannot compare values of type ${typeof a}`, ast);
-}

package/dist/runtime/vendor/cel-js/lib/parser.d.ts

@@ -1,83 +0,0 @@
-import type { Effect } from 'effect';
-import type { IOperatorDef, ASTMeta, ITypeCheckerBase, IContextBase, IFullEvaluator, ITypeDeclaration, IASTNode } from './types.js.js';
-import type { Limits } from './options.js.js';
-export declare class ASTNode {
-    #private;
-    op: string;
-    args: unknown;
-    pos: number;
-    start: number;
-    end: number;
-    constructor(input: string, pos: number, start: number, end: number, op: IOperatorDef, args: unknown);
-    clone(op: IOperatorDef, args: unknown): ASTNode;
-    get meta(): ASTMeta;
-    get input(): string;
-    check(chk: ITypeCheckerBase, ast: IASTNode, ctx: IContextBase): ITypeDeclaration;
-    evaluate(ev: IFullEvaluator, ast: IASTNode, ctx: IContextBase): Effect.Effect<unknown, unknown>;
-    setMeta(key: string, value: unknown): this;
-    get range(): {
-        start: number;
-        end: number;
-    };
-    toOldStructure(): unknown[];
-}
-declare class Lexer {
-    #private;
-    input: string;
-    pos: number;
-    length: number;
-    tokenPos: number;
-    tokenType: number;
-    tokenValue: unknown;
-    reset(input: string): string;
-    token(pos: number, type: number, value?: unknown): this;
-    nextToken(): this;
-    _isIdentifierCharCode(c: number): boolean;
-    _parseAsNumber(start: number, end: number): this;
-    _parseAsHexNumber(start: number, end: number): this;
-    _readDigits(input: string, length: number, pos: number, code?: number): number;
-    _readExponent(input: string, length: number, pos: number): number;
-    readNumber(): this;
-    readString(del: string, prefix?: string): this;
-    _closeQuotedString(rawStart: number, rawValue: string, prefix: string | undefined, pos: number): this;
-    readSingleQuotedString(delimiter: string, prefix?: string): this;
-    readTripleQuotedString(delimiter: string, prefix?: string): this;
-    processEscapes(offset: number, str: string, isBytes: boolean): string;
-    readIdentifier(): this;
-}
-interface IParserRegistry {
-    findMacro(name: string, hasReceiver: boolean, argLen: number): {
-        handler: (...args: unknown[]) => unknown;
-    } | false | null | undefined;
-}
-export declare class Parser {
-    #private;
-    lexer: Lexer;
-    input: string | undefined;
-    maxDepthRemaining: number | undefined;
-    astNodesRemaining: number | undefined;
-    type: number | undefined;
-    pos: number | undefined;
-    limits: Limits;
-    registry: IParserRegistry;
-    constructor(limits: Limits, registry: IParserRegistry);
-    get value(): unknown;
-    consume(expectedType: number): number;
-    match(type: number): boolean;
-    parse(input: unknown): ASTNode;
-    parseExpression(): ASTNode;
-    parseLogicalOr(): ASTNode;
-    parseLogicalAnd(): ASTNode;
-    parseEquality(): ASTNode;
-    parseRelational(): ASTNode;
-    parseAdditive(): ASTNode;
-    parseMultiplicative(): ASTNode;
-    parseUnary(): ASTNode;
-    parsePostfix(): ASTNode;
-    parsePrimary(): ASTNode;
-    parseList(): ASTNode;
-    parseMap(): ASTNode;
-    parseProperty(): [ASTNode, ASTNode];
-    parseArgumentList(): ASTNode[];
-}
-export {};