@shwfed/nuxt 0.7.8 → 0.7.10

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

@@ -0,0 +1,14 @@
+export function toggleOptionalTypes(registry: any, enable: any): void;
+export function register(registry: any): void;
+export class Optional {
+    static of(value: any): Readonly<Optional>;
+    static none(): Readonly<Optional>;
+    constructor(value: any);
+    hasValue(): boolean;
+    value(): any;
+    or(optional: any): Optional;
+    orValue(defaultValue: any): any;
+    get [Symbol.toStringTag](): string;
+    #private;
+}
+export const OPTIONAL_NONE: Readonly<Optional>;

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

@@ -0,0 +1,161 @@
+import {EvaluationError} from './errors.js'
+
+export class Optional {
+  #value
+
+  constructor(value) {
+    this.#value = value
+  }
+
+  static of(value) {
+    if (value === undefined) return OPTIONAL_NONE
+    return new Optional(value)
+  }
+
+  static none() {
+    return OPTIONAL_NONE
+  }
+
+  hasValue() {
+    return this.#value !== undefined
+  }
+
+  value() {
+    if (this.#value === undefined) throw new EvaluationError('Optional value is not present')
+    return this.#value
+  }
+
+  or(optional) {
+    if (this.#value !== undefined) return this
+    if (optional instanceof Optional) return optional
+    throw new EvaluationError('Optional.or must be called with an Optional argument')
+  }
+
+  orValue(defaultValue) {
+    return this.#value === undefined ? defaultValue : this.#value
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'optional'
+  }
+
+  [Symbol.for('nodejs.util.inspect.custom')]() {
+    return this.#value === undefined
+      ? `Optional { none }`
+      : `Optional { value: ${JSON.stringify(this.#value)} }`
+  }
+}
+
+export const OPTIONAL_NONE = Object.freeze(new Optional())
+
+class OptionalNamespace {}
+const optionalNamespace = new OptionalNamespace()
+
+export function toggleOptionalTypes(registry, enable) {
+  const optionalConstant = enable ? optionalNamespace : undefined
+  registry.deleteVariable('optional')
+  registry.registerConstant('optional', 'OptionalNamespace', optionalConstant)
+}
+
+export function register(registry) {
+  const sync = {async: false}
+  const functionOverload = (sig, handler) => registry.registerFunctionOverload(sig, handler, sync)
+
+  const optionalConstant = registry.enableOptionalTypes ? optionalNamespace : undefined
+  registry.registerType('OptionalNamespace', OptionalNamespace)
+  registry.registerConstant('optional', 'OptionalNamespace', optionalConstant)
+  functionOverload('optional.hasValue(): bool', (v) => v.hasValue())
+  functionOverload('optional<A>.value(): A', (v) => v.value())
+  registry.registerFunctionOverload('OptionalNamespace.none(): optional<T>', () => Optional.none())
+  functionOverload('OptionalNamespace.of(A): optional<A>', (_, value) => Optional.of(value))
+  function ensureOptional(value, ast, description) {
+    if (value instanceof Optional) return value
+    throw new EvaluationError(`${description} must be optional`, ast)
+  }
+
+  function evaluateOptional(ev, macro, ctx) {
+    const v = ev.eval(macro.receiver, ctx)
+    if (v instanceof Promise) return v.then((_v) => handleOptionalResolved(_v, ev, macro, ctx))
+    return handleOptionalResolved(v, ev, macro, ctx)
+  }
+
+  function handleOptionalResolved(value, ev, macro, ctx) {
+    const optional = ensureOptional(value, macro.receiver, `${macro.functionDesc} receiver`)
+    if (optional.hasValue()) return macro.onHasValue(optional)
+    return 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 new checker.Error(`${description} must be optional, got '${type}'`, node)
+  }
+
+  function createOptionalMacro({functionDesc, evaluate, typeCheck, onHasValue, onEmpty}) {
+    return ({ast, args, receiver}) => ({
+      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)
+        if (!(macro.receiver.maybeAsync || macro.arg.maybeAsync)) macro.ast.setMeta('async', false)
+
+        const unified = l.unify(check.registry, r)
+        if (unified) return unified
+        throw new check.Error(
+          `${macro.functionDesc} argument must be compatible type, got '${l}' and '${r}'`,
+          macro.arg
+        )
+      },
+      onHasValue: (optional) => optional,
+      onEmpty(ev, macro, ctx) {
+        const ast = macro.arg
+        const v = ev.eval(ast, ctx)
+        if (v instanceof Promise) return v.then((_v) => ensureOptional(_v, ast, invalidOrArg))
+        return ensureOptional(v, ast, invalidOrArg)
+      }
+    })
+  )
+
+  registry.registerFunctionOverload(
+    'optional.orValue(ast): dyn',
+    createOptionalMacro({
+      functionDesc: 'optional.orValue(value)',
+      onHasValue: (optionalValue) => optionalValue.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 (!(macro.receiver.maybeAsync || macro.arg.maybeAsync)) macro.ast.setMeta('async', false)
+
+        const unified = l.unify(check.registry, r)
+        if (unified) return unified
+        throw new check.Error(
+          `${macro.functionDesc} argument must be compatible type, got '${l}' and '${r}'`,
+          macro.arg
+        )
+      }
+    })
+  )
+}

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

@@ -0,0 +1,23 @@
+export function createOptions(opts: any, base?: Readonly<{
+    unlistedVariablesAreDyn: false;
+    homogeneousAggregateLiterals: true;
+    enableOptionalTypes: false;
+    limits: Readonly<{
+        maxAstNodes: 100000;
+        maxDepth: 250;
+        maxListElements: 1000;
+        maxMapEntries: 1000;
+        maxCallArguments: 32;
+    }>;
+}>): Readonly<{
+    unlistedVariablesAreDyn: boolean;
+    homogeneousAggregateLiterals: boolean;
+    enableOptionalTypes: boolean;
+    limits: Readonly<{
+        maxAstNodes: 100000;
+        maxDepth: 250;
+        maxListElements: 1000;
+        maxMapEntries: 1000;
+        maxCallArguments: 32;
+    }>;
+}>;

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

@@ -0,0 +1,47 @@
+import {objFreeze, objKeys} from './globals.js'
+
+const DEFAULT_LIMITS = objFreeze({
+  maxAstNodes: 100000,
+  maxDepth: 250,
+  maxListElements: 1000,
+  maxMapEntries: 1000,
+  maxCallArguments: 32
+})
+
+const LIMIT_KEYS = new Set(objKeys(DEFAULT_LIMITS))
+function createLimits(overrides, base = DEFAULT_LIMITS) {
+  const keys = overrides ? objKeys(overrides) : undefined
+  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,
+  homogeneousAggregateLiterals: true,
+  enableOptionalTypes: 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'),
+    homogeneousAggregateLiterals: bool(opts, base, 'homogeneousAggregateLiterals'),
+    enableOptionalTypes: bool(opts, base, 'enableOptionalTypes'),
+    limits: createLimits(opts.limits, base.limits)
+  })
+}

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

@@ -0,0 +1 @@
+export function registerOverloads(registry: any): void;

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

@@ -0,0 +1,214 @@
+import {UnsignedInt, Duration} from './functions.js'
+import {EvaluationError} from './errors.js'
+import {isArray, hasOwn, objKeys} from './globals.js'
+
+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)
+
+  const MAX_INT = 9223372036854775807n
+  const MIN_INT = -9223372036854775808n
+  function verifyInteger(v, ast) {
+    if (v <= MAX_INT && v >= MIN_INT) return v
+    throw new EvaluationError(`integer overflow: ${v}`, ast)
+  }
+
+  unaryOverload('!', 'bool', (a) => !a)
+  unaryOverload('-', 'int', (a) => -a)
+  binaryOverload('dyn<int>', `==`, `double`, (a, b) => a == b) // eslint-disable-line eqeqeq
+  binaryOverload('dyn<int>', `==`, `uint`, (a, b) => a == b.valueOf()) // eslint-disable-line eqeqeq
+  binaryOverload('int', '*', 'int', (a, b, ast) => verifyInteger(a * b, ast))
+  binaryOverload('int', '+', 'int', (a, b, ast) => verifyInteger(a + b, ast))
+  binaryOverload('int', '-', 'int', (a, b, ast) => verifyInteger(a - b, ast))
+  binaryOverload('int', '/', 'int', (a, b, ast) => {
+    if (b === 0n) throw new EvaluationError('division by zero', ast)
+    return a / b
+  })
+  binaryOverload('int', '%', 'int', (a, b, ast) => {
+    if (b === 0n) throw new EvaluationError('modulo by zero', ast)
+    return a % b
+  })
+
+  unaryOverload('-', 'double', (a) => -a)
+  binaryOverload('double', '*', 'double', (a, b) => a * b)
+  binaryOverload('double', '+', 'double', (a, b) => a + b)
+  binaryOverload('double', '-', 'double', (a, b) => a - b)
+  binaryOverload('double', '/', 'double', (a, b) => a / b)
+
+  binaryOverload('string', '+', 'string', (a, b) => a + b)
+  binaryOverload('list<V>', '+', 'list<V>', (a, b) => [...a, ...b])
+  binaryOverload('bytes', '+', 'bytes', (a, b) => {
+    if (!a.length) return b
+    if (!b.length) return a
+
+    const result = new Uint8Array(a.length + b.length)
+    result.set(a, 0)
+    result.set(b, a.length)
+    return result
+  })
+
+  const GPD = 'google.protobuf.Duration'
+  binaryOverload(GPD, '+', GPD, (a, b) => a.addDuration(b))
+  binaryOverload(GPD, '-', GPD, (a, b) => a.subtractDuration(b))
+  binaryOverload(GPD, '==', GPD, (a, b) => a.seconds === b.seconds && a.nanos === b.nanos)
+
+  const GPT = 'google.protobuf.Timestamp'
+  binaryOverload(GPT, '==', GPT, (a, b) => a.getTime() === b.getTime())
+  binaryOverload(GPT, '-', GPT, (a, b) => Duration.fromMilliseconds(a.getTime() - b.getTime()), GPD)
+  binaryOverload(GPT, '-', GPD, (a, b) => b.subtractTimestamp(a))
+  binaryOverload(GPT, '+', GPD, (a, b) => b.extendTimestamp(a))
+  binaryOverload(GPD, '+', GPT, (a, b) => a.extendTimestamp(b))
+
+  function listIncludes(value, list, ast, ev) {
+    if (list instanceof Set && list.has(value)) return true
+    for (const v of list) if (isEqual(value, v, ast, ev)) return true
+    return false
+  }
+
+  function mapIncludes(a, b) {
+    if (b instanceof Map) return b.get(a) !== undefined
+    return hasOwn(b, a) ? b[a] !== undefined : 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', 'int', 'double']) {
+    binaryOverload(t, '==', t, (a, b) => a === b)
+  }
+
+  binaryOverload('bytes', `==`, 'bytes', (a, b) => {
+    if (a === b) return true
+
+    let i = a.length
+    if (i !== b.length) return false
+    while (i--) if (a[i] !== b[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 length = a.length
+      if (length !== b.length) return false
+      for (let i = 0; i < length; i++) {
+        if (!isEqual(a[i], b[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
+    if (arr.length !== set?.size) return false
+    for (let i = 0; i < arr.length; i++) if (!set.has(arr[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 keysA = objKeys(a)
+    const keysB = objKeys(b)
+    if (keysA.length !== keysB.length) return false
+
+    for (let i = 0; i < keysA.length; i++) {
+      const key = keysA[i]
+      if (!(key in b && isEqual(a[key], b[key], ast, ev))) return false
+    }
+    return true
+  })
+
+  binaryOverload('uint', '==', 'uint', (a, b) => a.valueOf() === b.valueOf())
+  binaryOverload('dyn<uint>', `==`, `double`, (a, b) => a.valueOf() == b) // eslint-disable-line eqeqeq
+
+  binaryOverload('uint', '+', 'uint', (a, b) => new UnsignedInt(a.valueOf() + b.valueOf()))
+  binaryOverload('uint', '-', 'uint', (a, b) => new UnsignedInt(a.valueOf() - b.valueOf()))
+  binaryOverload('uint', '*', 'uint', (a, b) => new UnsignedInt(a.valueOf() * b.valueOf()))
+  binaryOverload('uint', '/', 'uint', (a, b, ast) => {
+    if (b.valueOf() === 0n) throw new EvaluationError('division by zero', ast)
+    return new UnsignedInt(a.valueOf() / b.valueOf())
+  })
+  binaryOverload('uint', '%', 'uint', (a, b, ast) => {
+    if (b.valueOf() === 0n) throw new EvaluationError('modulo by zero', ast)
+    return new UnsignedInt(a.valueOf() % b.valueOf())
+  })
+
+  for (const [left, right] of [
+    ['bool', 'bool'],
+    ['int', 'int'],
+    ['uint', 'uint'],
+    ['double', 'double'],
+    ['string', 'string'],
+    ['google.protobuf.Timestamp', 'google.protobuf.Timestamp'],
+    ['google.protobuf.Duration', 'google.protobuf.Duration'],
+    ['int', 'uint'],
+    ['int', 'double'],
+    ['double', 'int'],
+    ['double', 'uint'],
+    ['uint', 'int'],
+    ['uint', 'double']
+  ]) {
+    binaryOverload(left, '<', right, (a, b) => a < b)
+    binaryOverload(left, '<=', right, (a, b) => a <= b)
+    binaryOverload(left, '>', right, (a, b) => a > b)
+    binaryOverload(left, '>=', right, (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 'bigint':
+      // eslint-disable-next-line eqeqeq
+      if (typeof b === 'number') return a == b
+      return false
+    case 'number':
+      // eslint-disable-next-line eqeqeq
+      if (typeof b === 'bigint') return a == b
+      return false
+    case 'object':
+      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 new EvaluationError(`Cannot compare values of type ${typeof a}`, ast)
+}

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

@@ -0,0 +1,56 @@
+export class ASTNode {
+    constructor(input: any, pos: any, op: any, args: any);
+    op: any;
+    args: any;
+    clone(op: any, args: any): ASTNode;
+    get meta(): {
+        input: any;
+        pos: any;
+        evaluate: any;
+        check: any;
+    };
+    /**
+     * Check whether we can optimize away async calling
+     * If no ast members includes a function, we can optimize the call
+     * for which we want to return true here.
+     * @returns {boolean}
+     */
+    get maybeAsync(): boolean;
+    check(chk: any, ast: any, ctx: any): any;
+    evaluate(ev: any, ast: any, ctx: any): any;
+    setMeta(key: any, value: any): this;
+    get input(): any;
+    get pos(): any;
+    toOldStructure(): any[];
+    #private;
+}
+export class Parser {
+    constructor(limits: any, registry: any);
+    lexer: null;
+    input: null;
+    maxDepthRemaining: null;
+    astNodesRemaining: null;
+    type: null;
+    pos: null;
+    limits: any;
+    registry: any;
+    get value(): any;
+    consume(expectedType: any): null;
+    match(type: any): boolean;
+    parse(input: any): any;
+    parseExpression(): any;
+    parseLogicalOr(): any;
+    parseLogicalAnd(): any;
+    parseEquality(): any;
+    parseRelational(): any;
+    parseAdditive(): any;
+    parseMultiplicative(): any;
+    parseUnary(): any;
+    parsePostfix(): any;
+    parsePrimary(): any;
+    parseList(): any;
+    parseMap(): any;
+    parseProperty(): any[];
+    parseArgumentList(): any;
+    #private;
+}