hakojs/dist/esm/etc/types.js

A secure, embeddable JavaScript engine that runs untrusted code inside WebAssembly sandboxes with fine-grained permissions and resource limits

// src/etc/types.ts
import { PrimJSError } from "../etc/errors";
var LEPUS_EXCEPTION = -1;
var LEPUS_FALSE = 0;
var LEPUS_TRUE = 1;
function LEPUS_BOOLToBoolean(value) {
  switch (value) {
    case LEPUS_FALSE:
      return false;
    case LEPUS_TRUE:
      return true;
    default:
      throw new PrimJSError(`Invalid LEPUS_BOOL value: ${value}`);
  }
}
var INTRINSIC_BASE_OBJECTS = 1 << 0;
var INTRINSIC_DATE = 1 << 1;
var INTRINSIC_EVAL = 1 << 2;
var INTRINSIC_STRING_NORMALIZE = 1 << 3;
var INTRINSIC_REGEXP = 1 << 4;
var INTRINSIC_REGEXP_COMPILER = 1 << 5;
var INTRINSIC_JSON = 1 << 6;
var INTRINSIC_PROXY = 1 << 7;
var INTRINSIC_MAP_SET = 1 << 8;
var INTRINSIC_TYPED_ARRAYS = 1 << 9;
var INTRINSIC_PROMISE = 1 << 10;
var INTRINSIC_BIGINT = 1 << 11;
var INTRINSIC_BIGFLOAT = 1 << 12;
var INTRINSIC_BIGDECIMAL = 1 << 13;
var INTRINSIC_OPERATOR_OVERLOADING = 1 << 14;
var INTRINSIC_BIGNUM_EXT = 1 << 15;
var INTRINSIC_PERFORMANCE = 1 << 16;
var INTRINSIC_CRYPTO = 1 << 17;
var INTRINSIC_FLAG_MAP = {
  BaseObjects: INTRINSIC_BASE_OBJECTS,
  Date: INTRINSIC_DATE,
  Eval: INTRINSIC_EVAL,
  StringNormalize: INTRINSIC_STRING_NORMALIZE,
  RegExp: INTRINSIC_REGEXP,
  RegExpCompiler: INTRINSIC_REGEXP_COMPILER,
  JSON: INTRINSIC_JSON,
  Proxy: INTRINSIC_PROXY,
  MapSet: INTRINSIC_MAP_SET,
  TypedArrays: INTRINSIC_TYPED_ARRAYS,
  Promise: INTRINSIC_PROMISE,
  BigInt: INTRINSIC_BIGINT,
  BigFloat: INTRINSIC_BIGFLOAT,
  BigDecimal: INTRINSIC_BIGDECIMAL,
  OperatorOverloading: INTRINSIC_OPERATOR_OVERLOADING,
  BignumExt: INTRINSIC_BIGNUM_EXT,
  Performance: INTRINSIC_PERFORMANCE,
  Crypto: INTRINSIC_CRYPTO
};
var DefaultIntrinsics = Object.freeze({
  BaseObjects: true,
  Date: true,
  Eval: true,
  StringNormalize: true,
  RegExp: true,
  JSON: true,
  Proxy: true,
  MapSet: true,
  TypedArrays: true,
  Promise: true
});
function intrinsicsToFlags(intrinsics) {
  return Object.entries(intrinsics).reduce((result, [key, enabled]) => {
    if (enabled && key in INTRINSIC_FLAG_MAP) {
      return result | INTRINSIC_FLAG_MAP[key];
    }
    return result;
  }, 0);
}
var EVAL_FLAG_GLOBAL = 0;
var EVAL_FLAG_MODULE = 1 << 0;
var EVAL_FLAG_DIRECT = 2 << 0;
var EVAL_FLAG_INDIRECT = 3 << 0;
var EVAL_FLAG_TYPE_MASK = 3 << 0;
var EVAL_FLAG_STRICT = 1 << 3;
var EVAL_FLAG_RESERVED = 1 << 4;
var EVAL_FLAG_COMPILE_ONLY = 1 << 5;
var EVAL_FLAG_DEBUGGER_NO_PERSIST_SCRIPT = 1 << 6;
var JS_STRIP_SOURCE = 1 << 0;
var JS_STRIP_DEBUG = 1 << 1;
function evalOptionsToFlags(evalOptions) {
  if (typeof evalOptions === "number") {
    return evalOptions;
  }
  if (evalOptions === undefined) {
    return EVAL_FLAG_GLOBAL;
  }
  if (evalOptions.type !== undefined && evalOptions.type !== "global" && evalOptions.type !== "module") {
    throw new PrimJSError(`Invalid eval type: ${evalOptions.type}. Must be "global" or "module".`);
  }
  const { type, strict, compileOnly, noPersist } = evalOptions;
  let flags = 0;
  if (type === "global")
    flags |= EVAL_FLAG_GLOBAL;
  if (type === "module")
    flags |= EVAL_FLAG_MODULE;
  if (strict)
    flags |= EVAL_FLAG_STRICT;
  if (compileOnly)
    flags |= EVAL_FLAG_COMPILE_ONLY;
  if (noPersist)
    flags |= EVAL_FLAG_DEBUGGER_NO_PERSIST_SCRIPT;
  return flags;
}
var PROPERTY_ENUM_STRING = 1 << 0;
var PROPERTY_ENUM_SYMBOL = 1 << 1;
var PROPERTY_ENUM_PRIVATE = 1 << 2;
var PROPERTY_ENUM_ENUMERABLE = 1 << 4;
var PROPERTY_ENUM_NON_ENUMERABLE = 1 << 5;
var PROPERTY_ENUM_CONFIGURABLE = 1 << 6;
var PROPERTY_ENUM_NON_CONFIGURABLE = 1 << 7;
var PROPERTY_ENUM_NUMBER = 1 << 14;
var PROPERTY_ENUM_COMPLIANT = 1 << 15;
function hasOptionsWithCause(error) {
  return "options" in error && error.options !== null && typeof error.options === "object" && "cause" in error.options;
}
function detectCircularReferences(obj, path = "root") {
  const seen = new Set;
  function traverse(value, currentPath) {
    if (typeof value !== "object" || value === null) {
      return;
    }
    if (seen.has(value)) {
      throw new TypeError(`Circular reference detected at ${currentPath}`);
    }
    seen.add(value);
    if (Array.isArray(value)) {
      for (let i = 0;i < value.length; i++) {
        traverse(value[i], `${currentPath}[${i}]`);
      }
    } else {
      for (const key of Object.keys(value)) {
        traverse(value[key], `${currentPath}.${key}`);
      }
    }
    seen.delete(value);
  }
  traverse(obj, path);
}
export {
  intrinsicsToFlags,
  hasOptionsWithCause,
  evalOptionsToFlags,
  detectCircularReferences,
  PROPERTY_ENUM_SYMBOL,
  PROPERTY_ENUM_STRING,
  PROPERTY_ENUM_PRIVATE,
  PROPERTY_ENUM_NUMBER,
  PROPERTY_ENUM_NON_ENUMERABLE,
  PROPERTY_ENUM_NON_CONFIGURABLE,
  PROPERTY_ENUM_ENUMERABLE,
  PROPERTY_ENUM_CONFIGURABLE,
  PROPERTY_ENUM_COMPLIANT,
  LEPUS_TRUE,
  LEPUS_FALSE,
  LEPUS_EXCEPTION,
  LEPUS_BOOLToBoolean,
  JS_STRIP_SOURCE,
  JS_STRIP_DEBUG,
  INTRINSIC_TYPED_ARRAYS,
  INTRINSIC_STRING_NORMALIZE,
  INTRINSIC_REGEXP_COMPILER,
  INTRINSIC_REGEXP,
  INTRINSIC_PROXY,
  INTRINSIC_PROMISE,
  INTRINSIC_PERFORMANCE,
  INTRINSIC_OPERATOR_OVERLOADING,
  INTRINSIC_MAP_SET,
  INTRINSIC_JSON,
  INTRINSIC_EVAL,
  INTRINSIC_DATE,
  INTRINSIC_CRYPTO,
  INTRINSIC_BIGNUM_EXT,
  INTRINSIC_BIGINT,
  INTRINSIC_BIGFLOAT,
  INTRINSIC_BIGDECIMAL,
  INTRINSIC_BASE_OBJECTS,
  EVAL_FLAG_TYPE_MASK,
  EVAL_FLAG_STRICT,
  EVAL_FLAG_RESERVED,
  EVAL_FLAG_MODULE,
  EVAL_FLAG_INDIRECT,
  EVAL_FLAG_GLOBAL,
  EVAL_FLAG_DIRECT,
  EVAL_FLAG_DEBUGGER_NO_PERSIST_SCRIPT,
  EVAL_FLAG_COMPILE_ONLY,
  DefaultIntrinsics
};

//# debugId=0ACA7959221DC63D64756E2164756E21
//# sourceMappingURL=types.js.map