@shwfed/config 1.0.0

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

@@ -0,0 +1,3 @@
+import type { IASTNode } from './types.js.js';
+export declare function serialize(ast: IASTNode): string;
+export default serialize;

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

@@ -0,0 +1,168 @@
+import { Decimal } from "./decimal.js";
+import { Option } from "effect";
+function serializeValue(value) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return String(value);
+  if (typeof value === "string") return serializeString(value);
+  if (value instanceof Decimal) return value.toString();
+  if (value instanceof Uint8Array) return serializeBytes(value);
+  if (Option.isOption(value)) {
+    if (Option.isSome(value)) return `optional.of(${serializeValue(value.value)})`;
+    return "optional.none()";
+  }
+  if (typeof value === "number" || typeof value === "bigint") return String(value);
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.every((k) => /^\d+$/.test(k))) {
+      const bytes = new Uint8Array(keys.length);
+      const obj = value;
+      for (let i = 0; i < keys.length; i++) bytes[i] = obj[i];
+      return serializeBytes(bytes);
+    }
+  }
+  return String(value);
+}
+export function serialize(ast) {
+  const { op, args } = ast;
+  switch (op) {
+    case "value":
+      return serializeValue(args);
+    case "id":
+      return args;
+    case "||":
+    case "&&":
+    case "==":
+    case "!=":
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+    case "in":
+    case "+":
+    case "-":
+    case "*":
+    case "/":
+    case "%": {
+      const binArgs = args;
+      return `${wrap(binArgs[0], op)} ${op} ${wrap(binArgs[1], op)}`;
+    }
+    case "!_":
+      return `!${wrap(args, op)}`;
+    case "-_": {
+      const uArg = args;
+      return ["+", "-", "*", "/", "%"].includes(uArg.op) ? `-(${serialize(uArg)})` : `-${serialize(uArg)}`;
+    }
+    case ".": {
+      const dotArgs = args;
+      return `${wrap(dotArgs[0], op)}.${dotArgs[1]}`;
+    }
+    case ".?": {
+      const dotqArgs = args;
+      return `${wrap(dotqArgs[0], op)}.?${dotqArgs[1]}`;
+    }
+    case "[]": {
+      const idxArgs = args;
+      return `${wrap(idxArgs[0], op)}[${serialize(idxArgs[1])}]`;
+    }
+    case "[?]": {
+      const idxqArgs = args;
+      return `${wrap(idxqArgs[0], op)}[?${serialize(idxqArgs[1])}]`;
+    }
+    case "call": {
+      const callArgs = args;
+      return `${callArgs[0]}(${callArgs[1].map(serialize).join(", ")})`;
+    }
+    case "rcall": {
+      const rcallArgs = args;
+      return `${wrap(rcallArgs[1], op)}.${rcallArgs[0]}(${rcallArgs[2].map(serialize).join(", ")})`;
+    }
+    case "list":
+      return `[${args.map(serialize).join(", ")}]`;
+    case "map":
+      return `{${args.map(([k, v]) => `${serialize(k)}: ${serialize(v)}`).join(", ")}}`;
+    case "?:": {
+      const ternArgs = args;
+      return `${wrap(ternArgs[0], op)} ? ${wrap(ternArgs[1], op)} : ${serialize(ternArgs[2])}`;
+    }
+    default:
+      throw new Error(`Unknown AST operation: ${op}`);
+  }
+}
+function serializeString(str) {
+  const escaped = str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\f/g, "\\f").replaceAll("\b", "\\b").replace(/\v/g, "\\v");
+  let result = "";
+  for (let i = 0; i < escaped.length; i++) {
+    const code = escaped.charCodeAt(i);
+    if (code < 32 || code > 126) {
+      result += code <= 65535 ? `\\u${code.toString(16).padStart(4, "0")}` : `\\U${code.toString(16).padStart(8, "0")}`;
+    } else {
+      result += escaped[i];
+    }
+  }
+  return `"${result}"`;
+}
+function serializeBytes(bytes) {
+  let result = 'b"';
+  for (const byte of bytes) {
+    if (byte === 92) result += "\\\\";
+    else if (byte === 34) result += '\\"';
+    else if (byte === 10) result += "\\n";
+    else if (byte === 13) result += "\\r";
+    else if (byte === 9) result += "\\t";
+    else if (byte >= 32 && byte <= 126) result += String.fromCharCode(byte);
+    else result += `\\x${byte.toString(16).padStart(2, "0")}`;
+  }
+  return `${result}"`;
+}
+const PRECEDENCE = {
+  "?:": 1,
+  "||": 2,
+  "&&": 3,
+  "==": 4,
+  "!=": 4,
+  "<": 5,
+  "<=": 5,
+  ">": 5,
+  ">=": 5,
+  "in": 5,
+  "+": 6,
+  "-": 6,
+  "-_": 6,
+  "*": 7,
+  "/": 7,
+  "%": 7,
+  "!_": 8,
+  ".": 9,
+  ".?": 9,
+  "[]": 9,
+  "[?]": 9,
+  "call": 9,
+  "rcall": 9
+};
+function needsParentheses(ast, parentOp) {
+  const childOp = ast.op;
+  const parentPrec = PRECEDENCE[parentOp] || 0;
+  const childPrec = PRECEDENCE[childOp] || 0;
+  if (childOp === "value" || childOp === "id" || childOp === "call" || childOp === "rcall" || childOp === "list" || childOp === "map") {
+    return false;
+  }
+  if ((parentOp === "*" || parentOp === "/" || parentOp === "%") && childOp === "-_") return false;
+  if (parentOp === "*" && childOp === "*" && ast.args[0]?.op === "-_") return false;
+  if ((childOp === "." || childOp === "[]" || childOp === ".?" || childOp === "[?]") && (parentOp === "." || parentOp === "[]" || parentOp === ".?" || parentOp === "[?]" || parentOp === "rcall"))
+    return false;
+  if (parentOp === "?:") return childOp === "?:";
+  if (parentOp === "!_" || parentOp === "-_") return childPrec < parentPrec;
+  if (parentOp === "/" && (childOp === "*" || childOp === "+" || childOp === "-")) return true;
+  if (childOp === "/" && parentOp !== void 0) return true;
+  if ((parentOp === "*" || parentOp === "/") && ["+", "-", "*", "/"].includes(childOp)) {
+    return true;
+  }
+  if (childPrec < parentPrec) return true;
+  if (childPrec === parentPrec && (parentOp === "/" || parentOp === "%") && (childOp === "/" || childOp === "%"))
+    return true;
+  return false;
+}
+function wrap(ast, parentOp) {
+  return needsParentheses(ast, parentOp) ? `(${serialize(ast)})` : serialize(ast);
+}
+export default serialize;

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

@@ -0,0 +1,15 @@
+import { evaluationError } from './errors.js.js';
+import { Base } from './operators.js.js';
+import type { IASTNode, IContextBase, ITypeDeclaration, IRegistry } from './types.js.js';
+import type { ResolvedOptions } from './options.js.js';
+export declare class TypeChecker extends Base {
+    createError: typeof evaluationError;
+    constructor(opts: {
+        registry: IRegistry;
+        opts: ResolvedOptions;
+    }, isEvaluating?: boolean);
+    check(ast: IASTNode, ctx: IContextBase): ITypeDeclaration;
+    checkAccessOnType(ast: IASTNode, ctx: IContextBase, leftType: ITypeDeclaration, allowMissingField?: boolean): ITypeDeclaration;
+    formatType(type: ITypeDeclaration): string;
+    formatTypeList(types: ITypeDeclaration[]): string;
+}

package/dist/runtime/vendor/cel-js/lib/type-checker.js

@@ -0,0 +1,56 @@
+import { attachErrorAst, evaluationError, typeError } from "./errors.js";
+import { Base } from "./operators.js";
+const toDynTypeBinding = (/* @__PURE__ */ new Map()).set("A", "dyn").set("T", "dyn").set("K", "dyn").set("V", "dyn");
+export class TypeChecker extends Base {
+  constructor(opts, isEvaluating) {
+    super(opts);
+    this.createError = isEvaluating ? evaluationError : typeError;
+  }
+  check(ast, ctx) {
+    try {
+      return ast.checkedType ??= ast.check(this, ast, ctx);
+    } catch (error) {
+      throw attachErrorAst(error, ast);
+    }
+  }
+  checkAccessOnType(ast, ctx, leftType, allowMissingField = false) {
+    if (leftType === this.dynType) return leftType;
+    const indexTypeName = (ast.op === "[]" || ast.op === "[?]" ? this.check(ast.args[1], ctx) : this.stringType).type;
+    if (leftType.kind === "list") {
+      if (indexTypeName === "number" || indexTypeName === "dyn") return leftType.valueType;
+      throw this.createError("invalid_index_type", `List index must be number, got '${indexTypeName}'`, ast);
+    }
+    if (leftType.kind === "map") return leftType.valueType;
+    const customType = this.objectTypes.get(leftType.name);
+    if (customType) {
+      if (!(indexTypeName === "string" || indexTypeName === "dyn")) {
+        throw this.createError(
+          "invalid_index_type",
+          `Cannot index type '${leftType.name}' with type '${indexTypeName}'`,
+          ast
+        );
+      }
+      if (customType.fields) {
+        let keyName;
+        const astArgs = ast.args;
+        if (ast.op === "." || ast.op === ".?") keyName = astArgs[1];
+        else if (astArgs[1]?.op === "value") keyName = astArgs[1].args;
+        if (typeof keyName === "string") {
+          const fieldType = customType.fields[keyName];
+          if (fieldType) return fieldType;
+          if (allowMissingField) return this.dynType;
+          throw this.createError("no_such_key", `No such key: ${keyName}`, ast);
+        }
+      }
+      return this.dynType;
+    }
+    throw this.createError("cannot_index_type", `Cannot index type '${this.formatType(leftType)}'`, ast);
+  }
+  formatType(type) {
+    if (!type.hasPlaceholderType) return type.name;
+    return type.templated(this.registry, toDynTypeBinding).name;
+  }
+  formatTypeList(types) {
+    return types.map((t) => this.formatType(t)).join(", ");
+  }
+}

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

@@ -0,0 +1,192 @@
+import type { Effect, Either } from 'effect';
+/** Minimal Registry interface needed by TypeDeclaration.unify / .templated */
+export interface IRegistryBase {
+    getOptionalType(type: ITypeDeclaration): ITypeDeclaration;
+    getListType(type: ITypeDeclaration): ITypeDeclaration;
+    getMapType(a: ITypeDeclaration, b: ITypeDeclaration): ITypeDeclaration;
+}
+export interface IObjectTypeEntry {
+    name: string;
+    type: ITypeDeclaration;
+    fields?: Record<string, ITypeDeclaration>;
+    ctor?: unknown;
+    convert?: ((v: unknown) => unknown) | undefined;
+}
+/** Minimal evaluator interface needed by registry.ts (avoids circular import operators→registry) */
+export interface IEvaluatorBase {
+    objectTypesByConstructor: Map<object, IObjectTypeEntry>;
+    objectTypes: Map<string, IObjectTypeEntry>;
+    debugType(v: unknown): ITypeDeclaration;
+}
+export interface ITypeDeclaration {
+    kind: string;
+    type: string;
+    name: string;
+    keyType: ITypeDeclaration | undefined;
+    valueType: ITypeDeclaration | undefined;
+    unwrappedType: ITypeDeclaration;
+    wrappedType: ITypeDeclaration;
+    hasDynType: boolean;
+    hasPlaceholderType: boolean;
+    matchesValueType: ((v: unknown, ev: IEvaluatorBase) => boolean) | undefined;
+    fieldLazy: (obj: unknown, key: unknown, ast: IASTNode, ev: IEvaluatorBase) => unknown;
+    isDynOrBool(): boolean;
+    isEmpty(): boolean;
+    unify(r: IRegistryBase, t2: ITypeDeclaration): ITypeDeclaration | null;
+    templated(r: IRegistryBase, bind: Map<string, ITypeDeclaration> | null | undefined): ITypeDeclaration;
+    field(obj: unknown, key: unknown, ast: IASTNode, ev: IEvaluatorBase): unknown;
+    matches(o: ITypeDeclaration): boolean;
+    matchesBoth(o: ITypeDeclaration): boolean;
+    toString(): string;
+}
+export interface IOperatorMatch {
+    handler: (...args: unknown[]) => unknown;
+    returnType: ITypeDeclaration;
+    async?: boolean;
+    leftType?: ITypeDeclaration;
+    rightType?: ITypeDeclaration;
+    signature?: string;
+}
+export interface IFunctionMatch {
+    handler: (...args: unknown[]) => unknown;
+    returnType: ITypeDeclaration;
+    async?: boolean;
+    signature?: string;
+}
+export interface ICandidates {
+    returnType: ITypeDeclaration | null;
+    macro: unknown;
+    findFunction(argTypes: ITypeDeclaration[], receiverType?: ITypeDeclaration | null): IFunctionMatch | null;
+    findUnaryOverload(left: ITypeDeclaration): IOperatorMatch | false;
+    findBinaryOverload(left: ITypeDeclaration, right: ITypeDeclaration): IOperatorMatch | false;
+    checkBinaryOverload(left: ITypeDeclaration, right: ITypeDeclaration): ITypeDeclaration | false;
+}
+export interface IRegistry extends IRegistryBase {
+    objectTypes: Map<string, IObjectTypeEntry>;
+    objectTypesByConstructor: Map<object, IObjectTypeEntry>;
+    operatorCandidates(op: string): ICandidates;
+    functionCandidates(rec: boolean, name: string, argLen: number): ICandidates;
+    findBinaryOverload(op: string, left: ITypeDeclaration, right: ITypeDeclaration): IOperatorMatch | false;
+    findUnaryOverload(op: string, left: ITypeDeclaration): IOperatorMatch | false;
+    getType(typename: string): ITypeDeclaration;
+}
+export interface IContextBase {
+    getValue(key: string): unknown;
+    getVariable(name: string): {
+        type: ITypeDeclaration;
+        constant: boolean;
+        value: unknown;
+        name: string;
+    } | undefined;
+    getCheckedValue(ev: IEvaluatorBase, ast: IASTNode): unknown;
+    forkWithVariable(iterVar: string, iterType: ITypeDeclaration): IOverlayContextBase;
+    accuType?: ITypeDeclaration;
+    accuValue?: unknown;
+}
+export interface IOverlayContextBase extends IContextBase {
+    iterValue: unknown;
+    iterVar: string;
+    iterType: ITypeDeclaration;
+    reuse(parent: IContextBase): IOverlayContextBase;
+    setIterValue(v: unknown, ev: IEvaluatorBase): this;
+    setAccuType(type: ITypeDeclaration): this;
+    setAccuValue(v: unknown): this;
+}
+/** ASTNode fields set dynamically during type-checking */
+export interface IASTNodeDynamic {
+    left?: IASTNode;
+    right?: IASTNode;
+    condition?: IASTNode;
+    handle?: (...args: unknown[]) => unknown;
+    candidates?: ICandidates;
+    argTypes?: ITypeDeclaration[];
+    leftStaticType?: ITypeDeclaration;
+    rightStaticType?: ITypeDeclaration;
+    receiverWithArgs?: IASTNode[];
+    checkedType?: ITypeDeclaration;
+}
+export interface IASTNode extends IASTNodeDynamic {
+    readonly op: string;
+    args: unknown;
+    readonly input: string;
+    readonly pos: number;
+    readonly start: number;
+    readonly end: number;
+    readonly meta: ASTMeta;
+    readonly range: {
+        start: number;
+        end: number;
+    };
+    check(chk: ITypeCheckerBase, ast: IASTNode, ctx: IContextBase): ITypeDeclaration;
+    evaluate(ev: IFullEvaluator, ast: IASTNode, ctx: IContextBase): Effect.Effect<unknown, unknown>;
+    setMeta(key: string, value: unknown): IASTNode;
+    clone(op: IOperatorDef, args: unknown): IASTNode;
+    toOldStructure(): unknown[];
+}
+export interface ITypeCheckerBase {
+    check(ast: IASTNode, ctx: IContextBase): ITypeDeclaration;
+    checkAccessOnType(ast: IASTNode, ctx: IContextBase, leftType: ITypeDeclaration, allowMissingField?: boolean): ITypeDeclaration;
+    registry: IRegistry;
+    dynType: ITypeDeclaration;
+    boolType: ITypeDeclaration;
+    getType(typename: string): ITypeDeclaration;
+    createError(code: string | {
+        code?: string;
+        message: string;
+        node?: IASTNode;
+        cause?: unknown;
+    }, message?: string, node?: IASTNode): Error;
+    formatType(type: ITypeDeclaration): string;
+    formatTypeList(types: ITypeDeclaration[]): string;
+    objectTypes: Map<string, IObjectTypeEntry>;
+    debugType(v: unknown): ITypeDeclaration;
+}
+/** Full evaluator interface used in operator check/evaluate functions */
+export interface IFullEvaluator extends IEvaluatorBase {
+    dynType: ITypeDeclaration;
+    optionalType: ITypeDeclaration;
+    listType: ITypeDeclaration;
+    registry: IRegistry;
+    createError(code: string | {
+        code?: string;
+        message: string;
+        node?: IASTNode;
+        cause?: unknown;
+    }, message?: string, node?: IASTNode): Error;
+    eval(ast: IASTNode, ctx: IContextBase): Effect.Effect<unknown, unknown>;
+    tryEval(ast: IASTNode, ctx: IContextBase): Effect.Effect<Either.Either<unknown, unknown>, never>;
+    debugTypeDeep(value: unknown): ITypeDeclaration;
+    debugRuntimeType(value: unknown, checkedType?: ITypeDeclaration): ITypeDeclaration;
+}
+export interface IOperatorDef {
+    name: string;
+    alias?: string;
+    check: (chk: ITypeCheckerBase, ast: IASTNode, ctx: IContextBase) => ITypeDeclaration;
+    evaluate: (ev: IFullEvaluator, ast: IASTNode, ctx: IContextBase) => Effect.Effect<unknown, unknown>;
+}
+export interface ASTMeta {
+    check: IOperatorDef['check'];
+    evaluate: IOperatorDef['evaluate'];
+    alternate?: IASTNode;
+    macro?: IMacroExpansion;
+    label?: string;
+    [key: string]: unknown;
+}
+export interface IMacroExpansion {
+    callAst?: IASTNode;
+    evaluate: (ev: IFullEvaluator, macro: IMacroExpansion, ctx: IContextBase) => Effect.Effect<unknown, unknown>;
+    typeCheck: (chk: ITypeCheckerBase, macro: IMacroExpansion, ctx: IContextBase) => ITypeDeclaration;
+    [key: string]: unknown;
+}
+/** Args shape for comprehension AST nodes */
+export interface ComprehensionArgs {
+    errorsAreFatal?: boolean;
+    iterable: IASTNode;
+    iterVarName: string;
+    init: IASTNode;
+    step: IASTNode;
+    condition?: (accu: unknown) => unknown;
+    result: (accu: unknown) => unknown;
+    kind?: string;
+    iterCtx?: IOverlayContextBase;
+}