@shwfed/config 1.1.5 → 2.0.0

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

@@ -1,3 +0,0 @@
-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

@@ -1,168 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,192 +0,0 @@
-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;
-}