hermium 0.1.2 → 0.1.4

package/dist/web-server/_libs/h3.mjs

@@ -0,0 +1,408 @@
+import { N as NullProtoObj } from "./rou3.mjs";
+import { F as FastURL, N as NodeResponse } from "./srvx.mjs";
+function decodePathname(pathname) {
+  return decodeURI(pathname.includes("%25") ? pathname.replace(/%25/g, "%2525") : pathname);
+}
+const kEventNS = "h3.internal.event.";
+const kEventRes = /* @__PURE__ */ Symbol.for(`${kEventNS}res`);
+const kEventResHeaders = /* @__PURE__ */ Symbol.for(`${kEventNS}res.headers`);
+const kEventResErrHeaders = /* @__PURE__ */ Symbol.for(`${kEventNS}res.err.headers`);
+var H3Event = class {
+  app;
+  req;
+  url;
+  context;
+  static __is_event__ = true;
+  constructor(req, context, app) {
+    this.context = context || req.context || new NullProtoObj();
+    this.req = req;
+    this.app = app;
+    const _url = req._url;
+    const url = _url && _url instanceof URL ? _url : new FastURL(req.url);
+    if (url.pathname.includes("%")) url.pathname = decodePathname(url.pathname);
+    this.url = url;
+  }
+  get res() {
+    return this[kEventRes] ||= new H3EventResponse();
+  }
+  get runtime() {
+    return this.req.runtime;
+  }
+  waitUntil(promise) {
+    this.req.waitUntil?.(promise);
+  }
+  toString() {
+    return `[${this.req.method}] ${this.req.url}`;
+  }
+  toJSON() {
+    return this.toString();
+  }
+  get node() {
+    return this.req.runtime?.node;
+  }
+  get headers() {
+    return this.req.headers;
+  }
+  get path() {
+    return this.url.pathname + this.url.search;
+  }
+  get method() {
+    return this.req.method;
+  }
+};
+var H3EventResponse = class {
+  status;
+  statusText;
+  get headers() {
+    return this[kEventResHeaders] ||= new Headers();
+  }
+  get errHeaders() {
+    return this[kEventResErrHeaders] ||= new Headers();
+  }
+};
+const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
+function sanitizeStatusMessage(statusMessage = "") {
+  return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
+}
+function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
+  if (!statusCode) return defaultStatusCode;
+  if (typeof statusCode === "string") statusCode = +statusCode;
+  if (statusCode < 100 || statusCode > 599) return defaultStatusCode;
+  return statusCode;
+}
+var HTTPError = class HTTPError2 extends Error {
+  get name() {
+    return "HTTPError";
+  }
+  status;
+  statusText;
+  headers;
+  cause;
+  data;
+  body;
+  unhandled;
+  static isError(input) {
+    return input instanceof Error && input?.name === "HTTPError";
+  }
+  static status(status, statusText, details) {
+    return new HTTPError2({
+      ...details,
+      statusText,
+      status
+    });
+  }
+  constructor(arg1, arg2) {
+    let messageInput;
+    let details;
+    if (typeof arg1 === "string") {
+      messageInput = arg1;
+      details = arg2;
+    } else details = arg1;
+    const status = sanitizeStatusCode(details?.status || details?.statusCode || details?.cause?.status || details?.cause?.statusCode, 500);
+    const statusText = sanitizeStatusMessage(details?.statusText || details?.statusMessage || details?.cause?.statusText || details?.cause?.statusMessage);
+    const message = messageInput || details?.message || details?.cause?.message || details?.statusText || details?.statusMessage || [
+      "HTTPError",
+      status,
+      statusText
+    ].filter(Boolean).join(" ");
+    super(message, { cause: details });
+    this.cause = details;
+    this.status = status;
+    this.statusText = statusText || void 0;
+    const rawHeaders = details?.headers || details?.cause?.headers;
+    this.headers = rawHeaders ? new Headers(rawHeaders) : void 0;
+    this.unhandled = details?.unhandled ?? details?.cause?.unhandled ?? void 0;
+    this.data = details?.data;
+    this.body = details?.body;
+  }
+  get statusCode() {
+    return this.status;
+  }
+  get statusMessage() {
+    return this.statusText;
+  }
+  toJSON() {
+    const unhandled = this.unhandled;
+    return {
+      status: this.status,
+      statusText: this.statusText,
+      unhandled,
+      message: unhandled ? "HTTPError" : this.message,
+      data: unhandled ? void 0 : this.data,
+      ...unhandled ? void 0 : this.body
+    };
+  }
+};
+function isJSONSerializable(value, _type) {
+  if (value === null || value === void 0) return true;
+  if (_type !== "object") return _type === "boolean" || _type === "number" || _type === "string";
+  if (typeof value.toJSON === "function") return true;
+  if (Array.isArray(value)) return true;
+  if (typeof value.pipe === "function" || typeof value.pipeTo === "function") return false;
+  if (value instanceof NullProtoObj) return true;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+const kNotFound = /* @__PURE__ */ Symbol.for("h3.notFound");
+const kHandled = /* @__PURE__ */ Symbol.for("h3.handled");
+function toResponse(val, event, config = {}) {
+  if (typeof val?.then === "function") return val.then((resolvedVal) => toResponse(resolvedVal, event, config), (r) => toResponse(typeof r === "number" ? new HTTPError({ status: r }) : r, event, config));
+  const response = prepareResponse(val, event, config);
+  if (typeof response?.then === "function") return toResponse(response, event, config);
+  const { onResponse } = config;
+  return onResponse ? Promise.resolve(onResponse(response, event)).then(() => response) : response;
+}
+var HTTPResponse = class {
+  #headers;
+  #init;
+  body;
+  constructor(body, init) {
+    this.body = body;
+    this.#init = init;
+  }
+  get status() {
+    return this.#init?.status || 200;
+  }
+  get statusText() {
+    return this.#init?.statusText || "OK";
+  }
+  get headers() {
+    return this.#headers ||= new Headers(this.#init?.headers);
+  }
+};
+function prepareResponse(val, event, config, nested) {
+  if (val === kHandled) return new NodeResponse(null);
+  if (val === kNotFound) val = new HTTPError({
+    status: 404,
+    message: `Cannot find any route matching [${event.req.method}] ${event.url}`
+  });
+  if (val && val instanceof Error) {
+    const isHTTPError = HTTPError.isError(val);
+    const error = isHTTPError ? val : new HTTPError(val);
+    if (!isHTTPError) {
+      error.unhandled = true;
+      if (val?.stack) error.stack = val.stack;
+    }
+    if (error.unhandled && !config.silent) console.error(error);
+    const { onError } = config;
+    const errHeaders = event[kEventRes]?.[kEventResErrHeaders];
+    return onError && !nested ? Promise.resolve(onError(error, event)).catch((error2) => error2).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug, errHeaders);
+  }
+  const preparedRes = event[kEventRes];
+  const preparedHeaders = preparedRes?.[kEventResHeaders];
+  event[kEventRes] = void 0;
+  if (!(val instanceof Response)) {
+    const res = prepareResponseBody(val, event, config);
+    const status = res.status || preparedRes?.status;
+    return new NodeResponse(nullBody(event.req.method, status) ? null : res.body, {
+      status,
+      statusText: res.statusText || preparedRes?.statusText,
+      headers: res.headers && preparedHeaders ? mergeHeaders$1(res.headers, preparedHeaders) : res.headers || preparedHeaders
+    });
+  }
+  if (!preparedHeaders || nested || !val.ok) return val;
+  try {
+    mergeHeaders$1(val.headers, preparedHeaders, val.headers);
+    return val;
+  } catch {
+    return new NodeResponse(nullBody(event.req.method, val.status) ? null : val.body, {
+      status: val.status,
+      statusText: val.statusText,
+      headers: mergeHeaders$1(val.headers, preparedHeaders)
+    });
+  }
+}
+function mergeHeaders$1(base, overrides, target = new Headers(base)) {
+  for (const [name, value] of overrides) if (name === "set-cookie") target.append(name, value);
+  else target.set(name, value);
+  return target;
+}
+const frozen = (name) => (...args) => {
+  throw new Error(`Headers are frozen (${name} ${args.join(", ")})`);
+};
+var FrozenHeaders = class extends Headers {
+  set = frozen("set");
+  append = frozen("append");
+  delete = frozen("delete");
+};
+const emptyHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-length": "0" });
+const jsonHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-type": "application/json;charset=UTF-8" });
+function prepareResponseBody(val, event, config) {
+  if (val === null || val === void 0) return {
+    body: "",
+    headers: emptyHeaders
+  };
+  const valType = typeof val;
+  if (valType === "string") return { body: val };
+  if (val instanceof Uint8Array) {
+    event.res.headers.set("content-length", val.byteLength.toString());
+    return { body: val };
+  }
+  if (val instanceof HTTPResponse || val?.constructor?.name === "HTTPResponse") return val;
+  if (isJSONSerializable(val, valType)) return {
+    body: JSON.stringify(val, void 0, config.debug ? 2 : void 0),
+    headers: jsonHeaders
+  };
+  if (valType === "bigint") return {
+    body: val.toString(),
+    headers: jsonHeaders
+  };
+  if (val instanceof Blob) {
+    const headers = new Headers({
+      "content-type": val.type,
+      "content-length": val.size.toString()
+    });
+    let filename = val.name;
+    if (filename) {
+      filename = encodeURIComponent(filename);
+      headers.set("content-disposition", `filename="${filename}"; filename*=UTF-8''${filename}`);
+    }
+    return {
+      body: val.stream(),
+      headers
+    };
+  }
+  if (valType === "symbol") return { body: val.toString() };
+  if (valType === "function") return { body: `${val.name}()` };
+  return { body: val };
+}
+function nullBody(method, status) {
+  return method === "HEAD" || status === 100 || status === 101 || status === 102 || status === 204 || status === 205 || status === 304;
+}
+function errorResponse(error, debug, errHeaders) {
+  let headers = error.headers ? mergeHeaders$1(jsonHeaders, error.headers) : new Headers(jsonHeaders);
+  if (errHeaders) headers = mergeHeaders$1(headers, errHeaders);
+  return new NodeResponse(JSON.stringify({
+    ...error.toJSON(),
+    stack: debug && error.stack ? error.stack.split("\n").map((l) => l.trim()) : void 0
+  }, void 0, debug ? 2 : void 0), {
+    status: error.status,
+    statusText: error.statusText,
+    headers
+  });
+}
+function callMiddleware(event, middleware, handler, index = 0) {
+  if (index === middleware.length) return handler(event);
+  const fn = middleware[index];
+  let nextCalled;
+  let nextResult;
+  const next = () => {
+    if (nextCalled) return nextResult;
+    nextCalled = true;
+    nextResult = callMiddleware(event, middleware, handler, index + 1);
+    return nextResult;
+  };
+  const ret = fn(event, next);
+  return isUnhandledResponse(ret) ? next() : typeof ret?.then === "function" ? ret.then((resolved) => isUnhandledResponse(resolved) ? next() : resolved) : ret;
+}
+function isUnhandledResponse(val) {
+  return val === void 0 || val === kNotFound;
+}
+function toRequest(input, options) {
+  if (typeof input === "string") {
+    let url = input;
+    if (url[0] === "/") {
+      const host = "localhost";
+      url = `${"http"}://${host}${url}`;
+    }
+    return new Request(url, options);
+  } else if (input instanceof URL) return new Request(input, options);
+  return input;
+}
+function defineHandler(input) {
+  if (typeof input === "function") return handlerWithFetch(input);
+  const handler = input.handler || (input.fetch ? function _fetchHandler(event) {
+    return input.fetch(event.req);
+  } : NoHandler);
+  return Object.assign(handlerWithFetch(input.middleware?.length ? function _handlerMiddleware(event) {
+    return callMiddleware(event, input.middleware, handler);
+  } : handler), input);
+}
+function handlerWithFetch(handler) {
+  if ("fetch" in handler) return handler;
+  return Object.assign(handler, { fetch: (req) => {
+    if (typeof req === "string") req = new URL(req, "http://_");
+    if (req instanceof URL) req = new Request(req);
+    const event = new H3Event(req);
+    try {
+      return Promise.resolve(toResponse(handler(event), event));
+    } catch (error) {
+      return Promise.resolve(toResponse(error, event));
+    }
+  } });
+}
+function defineLazyEventHandler(loader) {
+  let handler;
+  let promise;
+  return defineHandler(function lazyHandler(event) {
+    return handler ? handler(event) : (promise ??= Promise.resolve(loader()).then(function resolveLazyHandler(r) {
+      handler = toEventHandler(r) || toEventHandler(r.default);
+      if (typeof handler !== "function") throw new TypeError("Invalid lazy handler", { cause: { resolved: r } });
+      return handler;
+    })).then((r) => r(event));
+  });
+}
+function toEventHandler(handler) {
+  if (typeof handler === "function") return handler;
+  if (typeof handler?.handler === "function" && handler.constructor?.["~h3"]) return handler.handler;
+  if (typeof handler?.fetch === "function") return function _fetchHandler(event) {
+    return handler.fetch(event.req);
+  };
+}
+const NoHandler = () => kNotFound;
+var H3Core = class {
+  static "~h3" = true;
+  config;
+  "~middleware";
+  "~routes" = [];
+  constructor(config = {}) {
+    this["~middleware"] = [];
+    this.config = config;
+    this.fetch = this.fetch.bind(this);
+    this.handler = this.handler.bind(this);
+  }
+  fetch(request) {
+    return this["~request"](request);
+  }
+  handler(event) {
+    const route = this["~findRoute"](event);
+    if (route) {
+      event.context.params = route.params;
+      event.context.matchedRoute = route.data;
+    }
+    const routeHandler = route?.data.handler || NoHandler;
+    const middleware = this["~getMiddleware"](event, route);
+    return middleware.length > 0 ? callMiddleware(event, middleware, routeHandler) : routeHandler(event);
+  }
+  "~request"(request, context) {
+    const event = new H3Event(request, context, this);
+    let handlerRes;
+    try {
+      if (this.config.onRequest) {
+        const hookRes = this.config.onRequest(event);
+        handlerRes = typeof hookRes?.then === "function" ? hookRes.then(() => this.handler(event)) : this.handler(event);
+      } else handlerRes = this.handler(event);
+    } catch (error) {
+      handlerRes = Promise.reject(error);
+    }
+    return toResponse(handlerRes, event, this.config);
+  }
+  "~findRoute"(_event) {
+  }
+  "~addRoute"(_route) {
+    this["~routes"].push(_route);
+  }
+  "~getMiddleware"(_event, route) {
+    const routeMiddleware = route?.data.middleware;
+    const globalMiddleware = this["~middleware"];
+    return routeMiddleware ? [...globalMiddleware, ...routeMiddleware] : globalMiddleware;
+  }
+};
+export {
+  HTTPError as H,
+  defineLazyEventHandler as a,
+  H3Core as b,
+  toRequest as c,
+  defineHandler as d,
+  toEventHandler as t
+};

package/dist/web-server/_libs/hast-util-parse-selector.mjs

@@ -0,0 +1,39 @@
+const search = /[#.]/g;
+function parseSelector(selector, defaultTagName) {
+  const value = selector || "";
+  const props = {};
+  let start = 0;
+  let previous;
+  let tagName;
+  while (start < value.length) {
+    search.lastIndex = start;
+    const match = search.exec(value);
+    const subvalue = value.slice(start, match ? match.index : value.length);
+    if (subvalue) {
+      if (!previous) {
+        tagName = subvalue;
+      } else if (previous === "#") {
+        props.id = subvalue;
+      } else if (Array.isArray(props.className)) {
+        props.className.push(subvalue);
+      } else {
+        props.className = [subvalue];
+      }
+      start += subvalue.length;
+    }
+    if (match) {
+      previous = match[0];
+      start++;
+    }
+  }
+  return {
+    type: "element",
+    // @ts-expect-error: tag name is parsed.
+    tagName: tagName || defaultTagName || "div",
+    properties: props,
+    children: []
+  };
+}
+export {
+  parseSelector as p
+};