@piagent/platform 1.2.16 → 1.3.0-ie.8

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/middleware/ip-restriction/index.js

@@ -0,0 +1,176 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ip_restriction_exports = {};
+__export(ip_restriction_exports, {
+  ipRestriction: () => ipRestriction
+});
+module.exports = __toCommonJS(ip_restriction_exports);
+var import_http_exception = require("../../http-exception");
+var import_ipaddr = require("../../utils/ipaddr");
+const IS_CIDR_NOTATION_REGEX = /\/[^/]*$/;
+const parseCidrPrefix = (rule, prefix, max) => {
+  if (!/^[0-9]{1,3}$/.test(prefix)) {
+    throw new TypeError(`Invalid rule: ${rule}`);
+  }
+  const parsedPrefix = parseInt(prefix);
+  if (parsedPrefix > max) {
+    throw new TypeError(`Invalid rule: ${rule}`);
+  }
+  return parsedPrefix;
+};
+const buildMatcher = (rules) => {
+  const functionRules = [];
+  const staticRules = /* @__PURE__ */ new Set();
+  const staticIPv4Rules = /* @__PURE__ */ new Set();
+  const staticIPv6Rules = /* @__PURE__ */ new Set();
+  const cidrRules = [];
+  const registerStaticRule = (rule) => {
+    const type = (0, import_ipaddr.distinctRemoteAddr)(rule);
+    if (type === void 0) {
+      throw new TypeError(`Invalid rule: ${rule}`);
+    }
+    if (type === "IPv4") {
+      const ipv4binary = (0, import_ipaddr.convertIPv4ToBinary)(rule);
+      staticRules.add(rule);
+      staticRules.add(`::ffff:${rule}`);
+      staticIPv4Rules.add(ipv4binary);
+      staticIPv6Rules.add(0xffffn << 32n | ipv4binary);
+    } else {
+      const ipv6binary = (0, import_ipaddr.convertIPv6ToBinary)(rule);
+      const ipv6Addr = (0, import_ipaddr.convertIPv6BinaryToString)(ipv6binary);
+      staticRules.add(ipv6Addr);
+      staticIPv6Rules.add(ipv6binary);
+      if ((0, import_ipaddr.isIPv4MappedIPv6)(ipv6binary)) {
+        staticRules.add(ipv6Addr.substring(7));
+        staticIPv4Rules.add((0, import_ipaddr.convertIPv4MappedIPv6ToIPv4)(ipv6binary));
+      }
+    }
+  };
+  for (let rule of rules) {
+    if (rule === "*") {
+      return () => true;
+    } else if (typeof rule === "function") {
+      functionRules.push(rule);
+    } else {
+      if (IS_CIDR_NOTATION_REGEX.test(rule)) {
+        const separatedRule = rule.split("/");
+        const addrStr = separatedRule[0];
+        const type = (0, import_ipaddr.distinctRemoteAddr)(addrStr);
+        if (type === void 0) {
+          throw new TypeError(`Invalid rule: ${rule}`);
+        }
+        let isIPv4 = type === "IPv4";
+        let prefix = parseCidrPrefix(rule, separatedRule[1], isIPv4 ? 32 : 128);
+        if (isIPv4 ? prefix === 32 : prefix === 128) {
+          rule = addrStr;
+        } else {
+          let addr = (isIPv4 ? import_ipaddr.convertIPv4ToBinary : import_ipaddr.convertIPv6ToBinary)(addrStr);
+          if (type === "IPv6" && (0, import_ipaddr.isIPv4MappedIPv6)(addr) && prefix >= 96) {
+            isIPv4 = true;
+            addr = (0, import_ipaddr.convertIPv4MappedIPv6ToIPv4)(addr);
+            prefix -= 96;
+          }
+          const mask = (1n << BigInt(prefix)) - 1n << BigInt((isIPv4 ? 32 : 128) - prefix);
+          cidrRules.push([isIPv4, addr & mask, mask]);
+          continue;
+        }
+      }
+      registerStaticRule(rule);
+    }
+  }
+  return (remote) => {
+    if (staticRules.has(remote.addr)) {
+      return true;
+    }
+    const remoteAddr = remote.binaryAddr ||= (remote.isIPv4 ? import_ipaddr.convertIPv4ToBinary : import_ipaddr.convertIPv6ToBinary)(remote.addr);
+    const remoteIPv4Addr = remote.isIPv4 || (0, import_ipaddr.isIPv4MappedIPv6)(remoteAddr) ? remote.isIPv4 ? remoteAddr : (0, import_ipaddr.convertIPv4MappedIPv6ToIPv4)(remoteAddr) : void 0;
+    if ((remote.isIPv4 ? staticIPv4Rules : staticIPv6Rules).has(remoteAddr)) {
+      return true;
+    }
+    for (const [isIPv4, addr, mask] of cidrRules) {
+      if (isIPv4) {
+        if (remoteIPv4Addr === void 0) {
+          continue;
+        }
+        if ((remoteIPv4Addr & mask) === addr) {
+          return true;
+        }
+        continue;
+      }
+      if (remote.isIPv4) {
+        continue;
+      }
+      if ((remoteAddr & mask) === addr) {
+        return true;
+      }
+    }
+    for (const rule of functionRules) {
+      if (rule({ addr: remote.addr, type: remote.type })) {
+        return true;
+      }
+    }
+    return false;
+  };
+};
+const ipRestriction = (getIP, { denyList = [], allowList = [] }, onError) => {
+  const allowLength = allowList.length;
+  const denyMatcher = buildMatcher(denyList);
+  const allowMatcher = buildMatcher(allowList);
+  const blockError = (c) => new import_http_exception.HTTPException(403, {
+    res: c.text("Forbidden", {
+      status: 403
+    })
+  });
+  return async function ipRestriction2(c, next) {
+    const connInfo = getIP(c);
+    const addr = typeof connInfo === "string" ? connInfo : connInfo.remote.address;
+    if (!addr) {
+      throw blockError(c);
+    }
+    const type = typeof connInfo !== "string" && connInfo.remote.addressType || (0, import_ipaddr.distinctRemoteAddr)(addr);
+    const remoteData = { addr, type, isIPv4: type === "IPv4" };
+    try {
+      if (denyMatcher(remoteData)) {
+        if (onError) {
+          return onError({ addr, type }, c);
+        }
+        throw blockError(c);
+      }
+      if (allowMatcher(remoteData)) {
+        return await next();
+      }
+    } catch (e) {
+      if (e instanceof TypeError && e.code === import_ipaddr.INVALID_IP_ADDRESS_ERROR_CODE) {
+        throw blockError(c);
+      }
+      throw e;
+    }
+    if (allowLength === 0) {
+      return await next();
+    } else {
+      if (onError) {
+        return await onError({ addr, type }, c);
+      }
+      throw blockError(c);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ipRestriction
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/middleware/jsx-renderer/index.js

@@ -0,0 +1,82 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsx_renderer_exports = {};
+__export(jsx_renderer_exports, {
+  RequestContext: () => RequestContext,
+  jsxRenderer: () => jsxRenderer,
+  useRequestContext: () => useRequestContext
+});
+module.exports = __toCommonJS(jsx_renderer_exports);
+var import_html = require("../../helper/html");
+var import_jsx = require("../../jsx");
+var import_streaming = require("../../jsx/streaming");
+const RequestContext = (0, import_jsx.createContext)(null);
+const createRenderer = (c, Layout, component, options) => (children, props) => {
+  options = typeof options === "function" ? options(c) : options;
+  const docType = typeof options?.docType === "string" ? options.docType : options?.docType === false ? "" : "<!DOCTYPE html>";
+  const currentLayout = component ? (0, import_jsx.jsx)(
+    (props2) => component(props2, c),
+    {
+      Layout,
+      ...props
+    },
+    children
+  ) : children;
+  const body = import_html.html`${(0, import_html.raw)(docType)}${(0, import_jsx.jsx)(
+    RequestContext.Provider,
+    { value: c },
+    currentLayout
+  )}`;
+  if (options?.stream) {
+    if (options.stream === true) {
+      c.header("Transfer-Encoding", "chunked");
+      c.header("Content-Type", "text/html; charset=UTF-8");
+      c.header("Content-Encoding", "Identity");
+    } else {
+      for (const [key, value] of Object.entries(options.stream)) {
+        c.header(key, value);
+      }
+    }
+    return c.body((0, import_streaming.renderToReadableStream)(body));
+  } else {
+    return c.html(body);
+  }
+};
+const jsxRenderer = (component, options) => function jsxRenderer2(c, next) {
+  const Layout = c.getLayout() ?? import_jsx.Fragment;
+  if (component) {
+    c.setLayout((props) => {
+      return component({ ...props, Layout }, c);
+    });
+  }
+  c.setRenderer(createRenderer(c, Layout, component, options));
+  return next();
+};
+const useRequestContext = () => {
+  const c = (0, import_jsx.useContext)(RequestContext);
+  if (!c) {
+    throw new Error("RequestContext is not provided.");
+  }
+  return c;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RequestContext,
+  jsxRenderer,
+  useRequestContext
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/middleware/jwk/index.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jwk_exports = {};
+__export(jwk_exports, {
+  jwk: () => import_jwk.jwk
+});
+module.exports = __toCommonJS(jwk_exports);
+var import_jwk = require("./jwk");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jwk
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/middleware/jwk/jwk.js

@@ -0,0 +1,139 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jwk_exports = {};
+__export(jwk_exports, {
+  jwk: () => jwk
+});
+module.exports = __toCommonJS(jwk_exports);
+var import_cookie = require("../../helper/cookie");
+var import_http_exception = require("../../http-exception");
+var import_jwt = require("../../utils/jwt");
+var import_context = require("../../context");
+const jwk = (options, init) => {
+  const verifyOpts = options.verification || {};
+  if (!options || !(options.keys || options.jwks_uri)) {
+    throw new Error('JWK auth middleware requires options for either "keys" or "jwks_uri" or both');
+  }
+  if (!crypto.subtle || !crypto.subtle.importKey) {
+    throw new Error("`crypto.subtle.importKey` is undefined. JWK auth middleware requires it.");
+  }
+  return async function jwk2(ctx, next) {
+    const headerName = options.headerName || "Authorization";
+    const credentials = ctx.req.raw.headers.get(headerName);
+    let token;
+    if (credentials) {
+      const parts = credentials.split(/\s+/);
+      if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer") {
+        const errDescription = "invalid credentials structure";
+        throw new import_http_exception.HTTPException(401, {
+          message: errDescription,
+          res: unauthorizedResponse({
+            ctx,
+            error: "invalid_request",
+            errDescription,
+            realm: options.realm
+          })
+        });
+      } else {
+        token = parts[1];
+      }
+    } else if (options.cookie) {
+      if (typeof options.cookie == "string") {
+        token = (0, import_cookie.getCookie)(ctx, options.cookie);
+      } else if (options.cookie.secret) {
+        if (options.cookie.prefixOptions) {
+          token = await (0, import_cookie.getSignedCookie)(
+            ctx,
+            options.cookie.secret,
+            options.cookie.key,
+            options.cookie.prefixOptions
+          );
+        } else {
+          token = await (0, import_cookie.getSignedCookie)(ctx, options.cookie.secret, options.cookie.key);
+        }
+      } else {
+        if (options.cookie.prefixOptions) {
+          token = (0, import_cookie.getCookie)(ctx, options.cookie.key, options.cookie.prefixOptions);
+        } else {
+          token = (0, import_cookie.getCookie)(ctx, options.cookie.key);
+        }
+      }
+    }
+    if (!token) {
+      if (options.allow_anon) {
+        return next();
+      }
+      const errDescription = "no authorization included in request";
+      throw new import_http_exception.HTTPException(401, {
+        message: errDescription,
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_request",
+          errDescription,
+          realm: options.realm
+        })
+      });
+    }
+    let payload;
+    let cause;
+    try {
+      const keys = typeof options.keys === "function" ? await options.keys(ctx) : options.keys;
+      const jwks_uri = typeof options.jwks_uri === "function" ? await options.jwks_uri(ctx) : options.jwks_uri;
+      payload = await import_jwt.Jwt.verifyWithJwks(
+        token,
+        { keys, jwks_uri, verification: verifyOpts, allowedAlgorithms: options.alg },
+        init
+      );
+    } catch (e) {
+      cause = e;
+    }
+    if (!payload) {
+      if (cause instanceof Error && cause.constructor === Error) {
+        throw cause;
+      }
+      throw new import_http_exception.HTTPException(401, {
+        message: "Unauthorized",
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_token",
+          statusText: "Unauthorized",
+          errDescription: "token verification failure",
+          realm: options.realm
+        }),
+        cause
+      });
+    }
+    ctx.set("jwtPayload", payload);
+    await next();
+  };
+};
+function unauthorizedResponse(opts) {
+  const realm = (opts.realm ?? opts.ctx.req.url).replace(/"/g, '\\"');
+  const errDescription = opts.errDescription.replace(/"/g, '\\"');
+  return new Response("Unauthorized", {
+    status: 401,
+    statusText: opts.statusText,
+    headers: {
+      "WWW-Authenticate": `Bearer realm="${realm}",error="${opts.error}",error_description="${errDescription}"`
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jwk
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/middleware/jwt/index.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jwt_exports = {};
+__export(jwt_exports, {
+  AlgorithmTypes: () => import_jwa.AlgorithmTypes,
+  decode: () => import_jwt.decode,
+  jwt: () => import_jwt.jwt,
+  sign: () => import_jwt.sign,
+  verify: () => import_jwt.verify,
+  verifyWithJwks: () => import_jwt.verifyWithJwks
+});
+module.exports = __toCommonJS(jwt_exports);
+var import_jwt = require("./jwt");
+var import_jwa = require("../../utils/jwt/jwa");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlgorithmTypes,
+  decode,
+  jwt,
+  sign,
+  verify,
+  verifyWithJwks
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/middleware/jwt/jwt.js

@@ -0,0 +1,145 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jwt_exports = {};
+__export(jwt_exports, {
+  decode: () => decode,
+  jwt: () => jwt,
+  sign: () => sign,
+  verify: () => verify,
+  verifyWithJwks: () => verifyWithJwks
+});
+module.exports = __toCommonJS(jwt_exports);
+var import_cookie = require("../../helper/cookie");
+var import_http_exception = require("../../http-exception");
+var import_jwt = require("../../utils/jwt");
+var import_context = require("../../context");
+const jwt = (options) => {
+  const verifyOpts = options.verification || {};
+  if (!options || !options.secret) {
+    throw new Error('JWT auth middleware requires options for "secret"');
+  }
+  if (!options.alg) {
+    throw new Error('JWT auth middleware requires options for "alg"');
+  }
+  if (!crypto.subtle || !crypto.subtle.importKey) {
+    throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
+  }
+  return async function jwt2(ctx, next) {
+    const headerName = options.headerName || "Authorization";
+    const credentials = ctx.req.raw.headers.get(headerName);
+    let token;
+    if (credentials) {
+      const parts = credentials.split(/\s+/);
+      if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer") {
+        const errDescription = "invalid credentials structure";
+        throw new import_http_exception.HTTPException(401, {
+          message: errDescription,
+          res: unauthorizedResponse({
+            ctx,
+            error: "invalid_request",
+            errDescription,
+            realm: options.realm
+          })
+        });
+      } else {
+        token = parts[1];
+      }
+    } else if (options.cookie) {
+      if (typeof options.cookie == "string") {
+        token = (0, import_cookie.getCookie)(ctx, options.cookie);
+      } else if (options.cookie.secret) {
+        if (options.cookie.prefixOptions) {
+          token = await (0, import_cookie.getSignedCookie)(
+            ctx,
+            options.cookie.secret,
+            options.cookie.key,
+            options.cookie.prefixOptions
+          );
+        } else {
+          token = await (0, import_cookie.getSignedCookie)(ctx, options.cookie.secret, options.cookie.key);
+        }
+      } else {
+        if (options.cookie.prefixOptions) {
+          token = (0, import_cookie.getCookie)(ctx, options.cookie.key, options.cookie.prefixOptions);
+        } else {
+          token = (0, import_cookie.getCookie)(ctx, options.cookie.key);
+        }
+      }
+    }
+    if (!token) {
+      const errDescription = "no authorization included in request";
+      throw new import_http_exception.HTTPException(401, {
+        message: errDescription,
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_request",
+          errDescription,
+          realm: options.realm
+        })
+      });
+    }
+    let payload;
+    let cause;
+    try {
+      payload = await import_jwt.Jwt.verify(token, options.secret, {
+        alg: options.alg,
+        ...verifyOpts
+      });
+    } catch (e) {
+      cause = e;
+    }
+    if (!payload) {
+      throw new import_http_exception.HTTPException(401, {
+        message: "Unauthorized",
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_token",
+          statusText: "Unauthorized",
+          errDescription: "token verification failure",
+          realm: options.realm
+        }),
+        cause
+      });
+    }
+    ctx.set("jwtPayload", payload);
+    await next();
+  };
+};
+function unauthorizedResponse(opts) {
+  const realm = (opts.realm ?? opts.ctx.req.url).replace(/"/g, '\\"');
+  const errDescription = opts.errDescription.replace(/"/g, '\\"');
+  return new Response("Unauthorized", {
+    status: 401,
+    statusText: opts.statusText,
+    headers: {
+      "WWW-Authenticate": `Bearer realm="${realm}",error="${opts.error}",error_description="${errDescription}"`
+    }
+  });
+}
+const verifyWithJwks = import_jwt.Jwt.verifyWithJwks;
+const verify = import_jwt.Jwt.verify;
+const decode = import_jwt.Jwt.decode;
+const sign = import_jwt.Jwt.sign;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decode,
+  jwt,
+  sign,
+  verify,
+  verifyWithJwks
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/middleware/language/index.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var language_exports = {};
+__export(language_exports, {
+  detectFromCookie: () => import_language.detectFromCookie,
+  detectFromHeader: () => import_language.detectFromHeader,
+  detectFromPath: () => import_language.detectFromPath,
+  detectFromQuery: () => import_language.detectFromQuery,
+  languageDetector: () => import_language.languageDetector
+});
+module.exports = __toCommonJS(language_exports);
+var import_language = require("./language");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  languageDetector
+});