@shwfed/config 1.1.5 → 2.0.0

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

@@ -1,208 +0,0 @@
-const ZERO = 0n;
-const ONE = 1n;
-const TEN = 10n;
-const POW10 = [1n];
-function pow10(n) {
-  if (n < 0) return ONE;
-  while (POW10.length <= n) POW10.push(POW10[POW10.length - 1] * TEN);
-  return POW10[n];
-}
-function normalize(sign, coeff, exp) {
-  if (coeff === ZERO) return new Decimal(1, ZERO, 0);
-  while (coeff % TEN === ZERO) {
-    coeff /= TEN;
-    exp++;
-  }
-  return new Decimal(sign, coeff, exp);
-}
-function alignExp(a, b) {
-  const diff = a.exp - b.exp;
-  if (diff === 0) return [a.coeff, b.coeff, a.exp];
-  if (diff > 0) return [a.coeff * pow10(diff), b.coeff, b.exp];
-  return [a.coeff, b.coeff * pow10(-diff), a.exp];
-}
-function fromNumberString(s) {
-  if (s === "Infinity" || s === "+Infinity") return new Decimal(1, ZERO, 0);
-  if (s === "-Infinity") return new Decimal(-1, ZERO, 0);
-  if (s === "NaN") return new Decimal(1, ZERO, 0);
-  let sign = 1;
-  let i = 0;
-  if (s[0] === "-") {
-    sign = -1;
-    i = 1;
-  } else if (s[0] === "+") {
-    i = 1;
-  }
-  let mantissa, expPart = 0;
-  const eIdx = s.indexOf("e", i);
-  const EIdx = eIdx === -1 ? s.indexOf("E", i) : eIdx;
-  if (EIdx !== -1) {
-    mantissa = s.substring(i, EIdx);
-    expPart = Number(s.substring(EIdx + 1));
-  } else {
-    mantissa = s.substring(i);
-  }
-  const dotIdx = mantissa.indexOf(".");
-  let coeff, exp;
-  if (dotIdx === -1) {
-    coeff = BigInt(mantissa);
-    exp = expPart;
-  } else {
-    const intPart = mantissa.substring(0, dotIdx);
-    const fracPart = mantissa.substring(dotIdx + 1);
-    coeff = BigInt(intPart + fracPart);
-    exp = expPart - fracPart.length;
-  }
-  if (coeff === ZERO) return new Decimal(1, ZERO, 0);
-  return normalize(sign, coeff, exp);
-}
-export class Decimal {
-  sign;
-  coeff;
-  exp;
-  constructor(sign, coeff, exp) {
-    this.sign = sign;
-    this.coeff = coeff;
-    this.exp = exp;
-  }
-  static from(v) {
-    if (v instanceof Decimal) return v;
-    switch (typeof v) {
-      case "number": {
-        if (v === 0) return new Decimal(1, ZERO, 0);
-        if (!Number.isFinite(v)) return new Decimal(v < 0 ? -1 : 1, ZERO, 0);
-        return fromNumberString(String(v));
-      }
-      case "bigint": {
-        if (v === ZERO) return new Decimal(1, ZERO, 0);
-        const sign = v < ZERO ? -1 : 1;
-        return normalize(sign, v < ZERO ? -v : v, 0);
-      }
-      case "string": {
-        const s = v.trim();
-        if (!s) throw new Error("Cannot convert empty string to Decimal");
-        return fromNumberString(s);
-      }
-      default:
-        throw new Error(`Cannot convert ${typeof v} to Decimal`);
-    }
-  }
-  isZero() {
-    return this.coeff === ZERO;
-  }
-  isInteger() {
-    return this.exp >= 0;
-  }
-  neg() {
-    if (this.coeff === ZERO) return this;
-    return new Decimal(this.sign === 1 ? -1 : 1, this.coeff, this.exp);
-  }
-  abs() {
-    return this.sign === -1 ? this.neg() : this;
-  }
-  add(other) {
-    const o = Decimal.from(other);
-    if (this.isZero()) return o;
-    if (o.isZero()) return this;
-    const [ac, bc, exp] = alignExp(this, o);
-    const a = this.sign === 1 ? ac : -ac;
-    const b = o.sign === 1 ? bc : -bc;
-    const sum = a + b;
-    if (sum === ZERO) return new Decimal(1, ZERO, 0);
-    const sign = sum < ZERO ? -1 : 1;
-    return normalize(sign, sum < ZERO ? -sum : sum, exp);
-  }
-  sub(other) {
-    return this.add(Decimal.from(other).neg());
-  }
-  mul(other) {
-    const o = Decimal.from(other);
-    if (this.isZero() || o.isZero()) return new Decimal(1, ZERO, 0);
-    const sign = this.sign === o.sign ? 1 : -1;
-    return normalize(sign, this.coeff * o.coeff, this.exp + o.exp);
-  }
-  div(other, precision = 20) {
-    const o = Decimal.from(other);
-    if (o.isZero()) throw new Error("Division by zero");
-    if (this.isZero()) return new Decimal(1, ZERO, 0);
-    const sign = this.sign === o.sign ? 1 : -1;
-    const scale = precision + o._digits() - this._digits() + 1;
-    const num = scale > 0 ? this.coeff * pow10(scale) : this.coeff;
-    const quot = num / o.coeff;
-    const exp = this.exp - o.exp - (scale > 0 ? scale : 0);
-    return normalize(sign, quot, exp);
-  }
-  mod(other) {
-    const o = Decimal.from(other);
-    if (o.isZero()) throw new Error("Modulo by zero");
-    if (this.isZero()) return new Decimal(1, ZERO, 0);
-    const [ac, bc, exp] = alignExp(this, o);
-    const sa = this.sign === 1 ? ac : -ac;
-    const sb = o.sign === 1 ? bc : -bc;
-    const rem = sa % sb;
-    if (rem === ZERO) return new Decimal(1, ZERO, 0);
-    const sign = rem < ZERO ? -1 : 1;
-    return normalize(sign, rem < ZERO ? -rem : rem, exp);
-  }
-  _digits() {
-    if (this.coeff === ZERO) return 1;
-    return this.coeff.toString().length;
-  }
-  cmp(other) {
-    const o = Decimal.from(other);
-    if (this.isZero() && o.isZero()) return 0;
-    if (this.sign !== o.sign) return this.sign > o.sign ? 1 : -1;
-    const [ac, bc] = alignExp(this, o);
-    if (ac === bc) return 0;
-    const raw = ac > bc ? 1 : -1;
-    return this.sign === 1 ? raw : -raw;
-  }
-  eq(other) {
-    return this.cmp(other) === 0;
-  }
-  lt(other) {
-    return this.cmp(other) < 0;
-  }
-  lte(other) {
-    return this.cmp(other) <= 0;
-  }
-  gt(other) {
-    return this.cmp(other) > 0;
-  }
-  gte(other) {
-    return this.cmp(other) >= 0;
-  }
-  toNumber() {
-    if (this.isZero()) return 0;
-    return Number(this.toString());
-  }
-  valueOf() {
-    return this.toNumber();
-  }
-  toString() {
-    if (this.isZero()) return "0";
-    const digits = this.coeff.toString();
-    const sign = this.sign === -1 ? "-" : "";
-    if (this.exp >= 0) {
-      return sign + digits + "0".repeat(this.exp);
-    }
-    const decimalPos = digits.length + this.exp;
-    if (decimalPos <= 0) {
-      return sign + "0." + "0".repeat(-decimalPos) + digits;
-    }
-    return sign + digits.substring(0, decimalPos) + "." + digits.substring(decimalPos);
-  }
-  toJSON() {
-    return this.toNumber();
-  }
-  get [Symbol.toStringTag]() {
-    return "Decimal";
-  }
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    return `Decimal { ${this.toString()} }`;
-  }
-  [Symbol.toPrimitive](hint) {
-    if (hint === "string") return this.toString();
-    return this.toNumber();
-  }
-}

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

@@ -1,50 +0,0 @@
-interface ErrorNode {
-    input?: string;
-    pos?: number;
-    start?: number;
-    end?: number;
-    op?: string;
-    args?: unknown;
-}
-interface SourceRange {
-    start: number;
-    end: number;
-}
-interface CelErrorOptions {
-    name: string;
-    code: string;
-    message: string;
-    node?: ErrorNode;
-    cause?: unknown;
-    range?: SourceRange;
-}
-interface ErrorShorthandOptions {
-    code?: string;
-    message: string;
-    node?: ErrorNode;
-    cause?: unknown;
-    range?: SourceRange;
-}
-export declare class CelError extends Error {
-    #private;
-    constructor({ name, code, message, node, cause, range }: CelErrorOptions);
-    get node(): ErrorNode | undefined;
-    get code(): string;
-    get range(): SourceRange | undefined;
-    get summary(): string;
-    withAst(node: ErrorNode): this;
-}
-export declare class ParseError extends CelError {
-    constructor(message: string | ErrorShorthandOptions, node?: ErrorNode, cause?: unknown);
-}
-export declare class EvaluationError extends CelError {
-    constructor(message: string | ErrorShorthandOptions, node?: ErrorNode, cause?: unknown);
-}
-export declare class TypeError extends CelError {
-    constructor(message: string | ErrorShorthandOptions, node?: ErrorNode, cause?: unknown);
-}
-export declare function parseError(code: string | ErrorShorthandOptions, message?: string, node?: ErrorNode): ParseError;
-export declare function evaluationError(code: string | ErrorShorthandOptions, message?: string, node?: ErrorNode): EvaluationError;
-export declare function typeError(code: string | ErrorShorthandOptions, message?: string, node?: ErrorNode): TypeError;
-export declare function attachErrorAst(error: unknown, node: ErrorNode): unknown;
-export {};

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

@@ -1,112 +0,0 @@
-export class CelError extends Error {
-  #node;
-  #code;
-  #range;
-  #summary;
-  constructor({ name, code, message, node, cause, range }) {
-    super(message, cause ? { cause } : void 0);
-    this.name = name;
-    this.#code = code;
-    this.#summary = message;
-    this.#node = node;
-    this.#range = range && normalizeRange(range) || normalizeRange(node);
-    if (!node?.input) return;
-    this.message = formatErrorWithHighlight(this.#summary, node, this.#range);
-  }
-  get node() {
-    return this.#node;
-  }
-  get code() {
-    return this.#code;
-  }
-  get range() {
-    return this.#range;
-  }
-  get summary() {
-    return this.#summary;
-  }
-  withAst(node) {
-    if (this.#node || !node?.input) return this;
-    this.#node = node;
-    this.#range ??= normalizeRange(node);
-    this.message = formatErrorWithHighlight(this.#summary, node, this.#range);
-    return this;
-  }
-}
-function normalizeArgs(name, defaultCode, message, node, cause) {
-  if (typeof message === "string") return { name, code: defaultCode, message, node, cause };
-  const opts = message;
-  if (typeof opts !== "object") throw new Error("First param to error must be a string or object");
-  return {
-    name,
-    code: opts.code || defaultCode,
-    message: opts.message,
-    node: opts.node,
-    cause: opts.cause,
-    range: opts.range
-  };
-}
-export class ParseError extends CelError {
-  constructor(message, node, cause) {
-    super(normalizeArgs("ParseError", "parse_error", message, node, cause));
-  }
-}
-export class EvaluationError extends CelError {
-  constructor(message, node, cause) {
-    super(normalizeArgs("EvaluationError", "evaluation_error", message, node, cause));
-  }
-}
-export class TypeError extends CelError {
-  constructor(message, node, cause) {
-    super(normalizeArgs("TypeError", "type_error", message, node, cause));
-  }
-}
-export function parseError(code, message, node) {
-  if (typeof code === "object") return new ParseError(code);
-  return new ParseError({ code, message, node });
-}
-export function evaluationError(code, message, node) {
-  if (typeof code === "object") return new EvaluationError(code);
-  return new EvaluationError({ code, message, node });
-}
-export function typeError(code, message, node) {
-  if (typeof code === "object") return new TypeError(code);
-  return new TypeError({ code, message, node });
-}
-function normalizeRange(node) {
-  const start = node?.pos ?? node?.start;
-  if (typeof start !== "number") return void 0;
-  const end = typeof node?.end === "number" ? node.end : start;
-  return { start, end };
-}
-function formatErrorWithHighlight(message, node, range) {
-  const pos = node.pos ?? range?.start;
-  if (typeof pos !== "number") return message;
-  const input = node.input;
-  let lineNum = 1;
-  let currentPos = 0;
-  let columnNum = 0;
-  while (currentPos < pos) {
-    if (input[currentPos] === "\n") {
-      lineNum++;
-      columnNum = 0;
-    } else {
-      columnNum++;
-    }
-    currentPos++;
-  }
-  let contextStart = pos;
-  let contextEnd = pos;
-  while (contextStart > 0 && input[contextStart - 1] !== "\n") contextStart--;
-  while (contextEnd < input.length && input[contextEnd] !== "\n") contextEnd++;
-  const line = input.slice(contextStart, contextEnd);
-  const highlight = `> ${`${lineNum}`.padStart(4, " ")} | ${line}
-${" ".repeat(9 + columnNum)}^`;
-  return `${message}
-
-${highlight}`;
-}
-export function attachErrorAst(error, node) {
-  if (error instanceof CelError) return error.withAst(node);
-  return error;
-}

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

@@ -1,37 +0,0 @@
-import { Either, Effect } from 'effect';
-import type { Registry } from './registry.js.js';
-import type { ParseError, EvaluationError, TypeError } from './errors.js.js';
-import type { ASTNode } from './parser.js.js';
-import type { Limits } from './options.js.js';
-interface ParsedExpression {
-    (context?: Record<string, unknown>): Effect.Effect<unknown, unknown>;
-    check: () => {
-        valid: boolean;
-        type?: string;
-        error?: unknown;
-    };
-    ast: ASTNode;
-}
-declare class Environment {
-    #private;
-    constructor(opts?: {
-        unlistedVariablesAreDyn?: boolean;
-        limits?: Partial<Limits>;
-    } | null, inherited?: Environment);
-    clone(opts?: {
-        unlistedVariablesAreDyn?: boolean;
-        limits?: Partial<Limits>;
-    } | null): Environment;
-    registerFunction(signature: string, handler?: (...args: unknown[]) => unknown, opts?: unknown): this;
-    registerOperator(signature: string, handler?: (...args: unknown[]) => unknown, opts?: unknown): this;
-    registerType(typename: string, constructor: unknown): this;
-    registerVariable(name: string, type?: unknown, opts?: unknown): this;
-    registerConstant(name: string, type: unknown, value: unknown): this;
-    getDefinitions(): ReturnType<Registry['getDefinitions']>;
-    check(expression: string): Either.Either<string, ParseError | TypeError>;
-    parse(expression: string): ParsedExpression;
-    evaluate<T>(expression: string, context?: Record<string, unknown>): Effect.Effect<T, ParseError | TypeError | EvaluationError>;
-}
-export declare function parse(expression: string): ParsedExpression;
-export declare function evaluate<T>(expression: string, context?: Record<string, unknown>): Effect.Effect<T, ParseError | TypeError | EvaluationError>;
-export { Environment };

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

@@ -1,163 +0,0 @@
-import { Either, Effect } from "effect";
-import { createRegistry, RootContext } from "./registry.js";
-import { evaluationError } from "./errors.js";
-import { registerFunctions } from "./functions.js";
-import { registerHttpBuiltins } from "./http-builtins.js";
-import { registerMacros } from "./macros.js";
-import { registerOverloads } from "./overloads.js";
-import { TypeChecker } from "./type-checker.js";
-import { Parser } from "./parser.js";
-import { createOptions } from "./options.js";
-import { Base } from "./operators.js";
-const globalRegistry = createRegistry();
-registerFunctions(globalRegistry);
-registerOverloads(globalRegistry);
-registerMacros(globalRegistry);
-registerHttpBuiltins(globalRegistry);
-class Environment {
-  #registry;
-  #evaluator;
-  #typeChecker;
-  #evalTypeChecker;
-  #parser;
-  #opts;
-  constructor(opts, inherited) {
-    this.#opts = createOptions(opts, inherited instanceof Environment ? inherited.#opts : void 0);
-    this.#registry = (inherited instanceof Environment ? inherited.#registry : globalRegistry).clone(this.#opts);
-    const childOpts = { registry: this.#registry, opts: this.#opts };
-    this.#typeChecker = new TypeChecker(childOpts);
-    this.#evalTypeChecker = new TypeChecker(childOpts, true);
-    this.#evaluator = new Evaluator(childOpts);
-    this.#parser = new Parser(this.#opts.limits, this.#registry);
-    Object.freeze(this);
-  }
-  clone(opts) {
-    return new Environment(opts, this);
-  }
-  registerFunction(signature, handler, opts) {
-    this.#registry.registerFunctionOverload(signature, handler, opts);
-    return this;
-  }
-  registerOperator(signature, handler, opts) {
-    this.#registry.registerOperatorOverload(signature, handler, opts);
-    return this;
-  }
-  registerType(typename, constructor) {
-    this.#registry.registerType(typename, constructor);
-    return this;
-  }
-  registerVariable(name, type, opts) {
-    this.#registry.registerVariable(name, type, opts);
-    return this;
-  }
-  registerConstant(name, type, value) {
-    this.#registry.registerConstant(name, type, value);
-    return this;
-  }
-  getDefinitions() {
-    return this.#registry.getDefinitions();
-  }
-  check(expression) {
-    try {
-      const ast = this.#parser.parse(expression);
-      const typeDecl = this.#typeChecker.check(ast, new RootContext(this.#registry));
-      return Either.right(this.#formatTypeForCheck(typeDecl));
-    } catch (error) {
-      return Either.left(error);
-    }
-  }
-  #formatTypeForCheck(typeDecl) {
-    if (typeDecl.name === `list<dyn>`) return "list";
-    if (typeDecl.name === `map<dyn, dyn>`) return "map";
-    return typeDecl.name;
-  }
-  parse(expression) {
-    const ast = this.#parser.parse(expression);
-    const evaluateFn = this.#evaluateAST.bind(this, ast);
-    evaluateFn.check = () => {
-      try {
-        const typeDecl = this.#typeChecker.check(ast, new RootContext(this.#registry));
-        return { valid: true, type: this.#formatTypeForCheck(typeDecl) };
-      } catch (error) {
-        return { valid: false, error };
-      }
-    };
-    evaluateFn.ast = ast;
-    return evaluateFn;
-  }
-  evaluate(expression, context) {
-    return Effect.try({
-      try: () => {
-        const ast = this.#parser.parse(expression);
-        const ctx = new RootContext(this.#registry, context);
-        if (!ast.checkedType) this.#evalTypeChecker.check(ast, ctx);
-        return { ast, ctx };
-      },
-      catch: (error) => error
-    }).pipe(
-      Effect.flatMap(({ ast, ctx }) => ast.evaluate(this.#evaluator, ast, ctx))
-    );
-  }
-  #evaluateAST(ast, context) {
-    return Effect.try({
-      try: () => {
-        const ctx = new RootContext(this.#registry, context);
-        if (!ast.checkedType) this.#evalTypeChecker.check(ast, ctx);
-        return ctx;
-      },
-      catch: (error) => error
-    }).pipe(
-      Effect.flatMap((ctx) => ast.evaluate(this.#evaluator, ast, ctx))
-    );
-  }
-}
-class Evaluator extends Base {
-  constructor(opts) {
-    super(opts);
-    this.createError = evaluationError;
-  }
-  #firstMapElement(coll) {
-    if (coll instanceof Map) return coll.entries().next().value;
-    for (const key in coll) return [key, coll[key]];
-    return void 0;
-  }
-  debugRuntimeType(value, checkedType) {
-    return checkedType?.hasDynType === false ? checkedType : this.debugTypeDeep(value);
-  }
-  debugTypeDeep(value) {
-    const runtimeType = this.debugType(value);
-    switch (runtimeType.kind) {
-      case "list": {
-        const first = value instanceof Array ? value[0] : value.values().next().value;
-        if (first === void 0) return runtimeType;
-        return this.registry.getListType(this.debugTypeDeep(first));
-      }
-      case "map": {
-        const first = this.#firstMapElement(value);
-        if (!first) return runtimeType;
-        return this.registry.getMapType(
-          runtimeType.keyType.hasDynType ? this.debugTypeDeep(first[0]) : runtimeType.keyType,
-          runtimeType.valueType.hasDynType ? this.debugTypeDeep(first[1]) : runtimeType.valueType
-        );
-      }
-      default:
-        return runtimeType;
-    }
-  }
-  tryEval(ast, ctx) {
-    return Effect.either(this.eval(ast, ctx));
-  }
-  eval(ast, ctx) {
-    return ast.evaluate(this, ast, ctx);
-  }
-}
-const globalEnvironment = new Environment({
-  unlistedVariablesAreDyn: true
-});
-export function parse(expression) {
-  return globalEnvironment.parse(expression);
-}
-export function evaluate(expression, context) {
-  return globalEnvironment.evaluate(expression, context);
-}
-export { Environment };

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

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