panoma 0.1.8 → 0.9.0

package/app/node_modules/hono/dist/jsx/streaming.js

@@ -1,155 +0,0 @@
-// src/jsx/streaming.ts
-import { raw } from "../helper/html/index.js";
-import { HtmlEscapedCallbackPhase, resolveCallback } from "../utils/html.js";
-import { JSXNode } from "./base.js";
-import { childrenToString } from "./components.js";
-import { DOM_RENDERER, DOM_STASH } from "./constants.js";
-import { captureRenderContext, createContext, useContext } from "./context.js";
-import { Suspense as SuspenseDomRenderer } from "./dom/components.js";
-import { buildDataStack } from "./dom/render.js";
-var StreamingContext = createContext(null);
-var suspenseCounter = 0;
-var Suspense = async ({
-  children,
-  fallback
-}) => {
-  if (!Array.isArray(children)) {
-    children = [children];
-  }
-  const nonce = useContext(StreamingContext)?.scriptNonce;
-  let resArray = [];
-  const stackNode = { [DOM_STASH]: [0, []] };
-  const popNodeStack = () => {
-    buildDataStack.pop();
-  };
-  try {
-    stackNode[DOM_STASH][0] = 0;
-    buildDataStack.push([[], stackNode]);
-    resArray = children.map(
-      (c) => c == null || typeof c === "boolean" ? "" : c.toString()
-    );
-  } catch (e) {
-    if (e instanceof Promise) {
-      const resume = captureRenderContext();
-      resArray = [
-        e.then(
-          () => resume(() => {
-            stackNode[DOM_STASH][0] = 0;
-            buildDataStack.push([[], stackNode]);
-            return childrenToString(children).finally(popNodeStack);
-          })
-        )
-      ];
-    } else {
-      throw e;
-    }
-  } finally {
-    popNodeStack();
-  }
-  if (resArray.some((res) => res instanceof Promise)) {
-    const index = suspenseCounter++;
-    const fallbackStr = await fallback.toString();
-    return raw(`<template id="H:${index}"></template>${fallbackStr}<!--/$-->`, [
-      ...fallbackStr.callbacks || [],
-      ({ phase, buffer, context }) => {
-        if (phase === HtmlEscapedCallbackPhase.BeforeStream) {
-          return;
-        }
-        return Promise.all(resArray).then(async (htmlArray) => {
-          htmlArray = htmlArray.flat();
-          const content = htmlArray.join("");
-          if (buffer) {
-            buffer[0] = buffer[0].replace(
-              new RegExp(`<template id="H:${index}"></template>.*?<!--/\\$-->`),
-              content
-            );
-          }
-          let html = buffer ? "" : `<template data-hono-target="H:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
-((d,c,n) => {
-c=d.currentScript.previousSibling
-d=d.getElementById('H:${index}')
-if(!d)return
-do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='/$')
-d.replaceWith(c.content)
-})(document)
-</script>`;
-          const callbacks = htmlArray.map((html2) => html2.callbacks || []).flat();
-          if (!callbacks.length) {
-            return html;
-          }
-          if (phase === HtmlEscapedCallbackPhase.Stream) {
-            html = await resolveCallback(html, HtmlEscapedCallbackPhase.BeforeStream, true, context);
-          }
-          return raw(html, callbacks);
-        });
-      }
-    ]);
-  } else {
-    return raw(resArray.join(""));
-  }
-};
-Suspense[DOM_RENDERER] = SuspenseDomRenderer;
-var textEncoder = new TextEncoder();
-var renderToReadableStream = (content, onError = console.trace) => {
-  let cancelled = false;
-  const reader = new ReadableStream({
-    async start(controller) {
-      try {
-        if (content instanceof JSXNode) {
-          content = content.toString();
-        }
-        const context = typeof content === "object" ? content : {};
-        const resolved = await resolveCallback(
-          content,
-          HtmlEscapedCallbackPhase.BeforeStream,
-          true,
-          context
-        );
-        if (!cancelled) {
-          controller.enqueue(textEncoder.encode(resolved));
-        }
-        let resolvedCount = 0;
-        const callbacks = [];
-        const then = (promise) => {
-          callbacks.push(
-            promise.catch((err) => {
-              console.log(err);
-              onError(err);
-              return "";
-            }).then(async (res) => {
-              res = await resolveCallback(
-                res,
-                HtmlEscapedCallbackPhase.BeforeStream,
-                true,
-                context
-              );
-              res.callbacks?.map((c) => c({ phase: HtmlEscapedCallbackPhase.Stream, context })).filter(Boolean).forEach(then);
-              resolvedCount++;
-              if (!cancelled) {
-                controller.enqueue(textEncoder.encode(res));
-              }
-            })
-          );
-        };
-        resolved.callbacks?.map((c) => c({ phase: HtmlEscapedCallbackPhase.Stream, context })).filter(Boolean).forEach(then);
-        while (resolvedCount !== callbacks.length) {
-          await Promise.all(callbacks);
-        }
-      } catch (e) {
-        onError(e);
-      }
-      if (!cancelled) {
-        controller.close();
-      }
-    },
-    cancel() {
-      cancelled = true;
-    }
-  });
-  return reader;
-};
-export {
-  StreamingContext,
-  Suspense,
-  renderToReadableStream
-};

package/app/node_modules/hono/dist/jsx/utils.js

@@ -1,175 +0,0 @@
-// src/jsx/utils.ts
-var normalizeElementKeyMap = /* @__PURE__ */ new Map([
-  ["className", "class"],
-  ["htmlFor", "for"],
-  ["crossOrigin", "crossorigin"],
-  ["httpEquiv", "http-equiv"],
-  ["itemProp", "itemprop"],
-  ["fetchPriority", "fetchpriority"],
-  ["noModule", "nomodule"],
-  ["formAction", "formaction"]
-]);
-var normalizeIntrinsicElementKey = (key) => normalizeElementKeyMap.get(key) || key;
-var invalidAttributeNameCharRe = /[\s"'<>/=`\\\x00-\x1f\x7f-\x9f]/;
-var validAttributeNameCache = /* @__PURE__ */ new Set();
-var validAttributeNameCacheMax = 1024;
-var invalidTagNameCharRe = /^[!?]|[\s"'<>/=`\\\x00-\x1f\x7f-\x9f]/;
-var validTagNameCache = /* @__PURE__ */ new Set();
-var validTagNameCacheMax = 256;
-var cacheValidName = (cache, max, name) => {
-  if (cache.size >= max) {
-    cache.clear();
-  }
-  cache.add(name);
-};
-var isValidTagName = (name) => {
-  if (validTagNameCache.has(name)) {
-    return true;
-  }
-  if (typeof name !== "string") {
-    return false;
-  }
-  if (name.length === 0) {
-    return true;
-  }
-  if (invalidTagNameCharRe.test(name)) {
-    return false;
-  }
-  cacheValidName(validTagNameCache, validTagNameCacheMax, name);
-  return true;
-};
-var isValidAttributeName = (name) => {
-  if (validAttributeNameCache.has(name)) {
-    return true;
-  }
-  const len = name.length;
-  if (len === 0) {
-    return false;
-  }
-  for (let i = 0; i < len; i++) {
-    const c = name.charCodeAt(i);
-    if (!(c >= 97 && c <= 122 || // a-z
-    c >= 65 && c <= 90 || // A-Z
-    c >= 48 && c <= 57 || // 0-9
-    c === 45 || // -
-    c === 95 || // _
-    c === 46 || // .
-    c === 58)) {
-      if (!invalidAttributeNameCharRe.test(name)) {
-        cacheValidName(validAttributeNameCache, validAttributeNameCacheMax, name);
-        return true;
-      } else {
-        return false;
-      }
-    }
-  }
-  cacheValidName(validAttributeNameCache, validAttributeNameCacheMax, name);
-  return true;
-};
-var invalidStylePropertyNameCharRe = /[\s"'():;\\/\[\]{}\x00-\x1f\x7f-\x9f]/;
-var validStylePropertyNameCache = /* @__PURE__ */ new Set();
-var validStylePropertyNameCacheMax = 1024;
-var isValidStylePropertyName = (name) => {
-  if (validStylePropertyNameCache.has(name)) {
-    return true;
-  }
-  const len = name.length;
-  if (len === 0) {
-    return false;
-  }
-  for (let i = 0; i < len; i++) {
-    const c = name.charCodeAt(i);
-    if (!(c >= 97 && c <= 122 || // a-z
-    c >= 65 && c <= 90 || // A-Z
-    c >= 48 && c <= 57 || // 0-9
-    c === 45 || // -
-    c === 95)) {
-      if (!invalidStylePropertyNameCharRe.test(name)) {
-        cacheValidName(validStylePropertyNameCache, validStylePropertyNameCacheMax, name);
-        return true;
-      } else {
-        return false;
-      }
-    }
-  }
-  cacheValidName(validStylePropertyNameCache, validStylePropertyNameCacheMax, name);
-  return true;
-};
-var unsafeStyleValueCharRe = /[;"'\\/\[\](){}]/;
-var hasUnsafeStyleValue = (value) => {
-  if (!unsafeStyleValueCharRe.test(value)) {
-    return false;
-  }
-  let quote = 0;
-  const blockStack = [];
-  for (let i = 0, len = value.length; i < len; i++) {
-    const c = value.charCodeAt(i);
-    if (c === 92) {
-      if (i === len - 1) {
-        return true;
-      }
-      i++;
-    } else if (quote !== 0) {
-      if (c === 10 || c === 12 || c === 13) {
-        return true;
-      }
-      if (c === quote) {
-        quote = 0;
-      }
-    } else if (c === 47 && value.charCodeAt(i + 1) === 42) {
-      const end = value.indexOf("*/", i + 2);
-      if (end === -1) {
-        return true;
-      }
-      i = end + 1;
-    } else if (c === 34 || c === 39) {
-      quote = c;
-    } else if (c === 40) {
-      blockStack.push(41);
-    } else if (c === 91) {
-      blockStack.push(93);
-    } else if (c === 123 || c === 125) {
-      return true;
-    } else if (c === 41 || c === 93) {
-      if (blockStack[blockStack.length - 1] !== c) {
-        return true;
-      }
-      blockStack.pop();
-    } else if (c === 59 && blockStack.length === 0) {
-      return true;
-    }
-  }
-  return quote !== 0 || blockStack.length !== 0;
-};
-var styleObjectForEach = (style, fn) => {
-  for (const [k, v] of Object.entries(style)) {
-    const key = k[0] === "-" || !/[A-Z]/.test(k) ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-    if (!isValidStylePropertyName(key)) {
-      continue;
-    }
-    if (v == null) {
-      fn(key, null);
-      continue;
-    }
-    let value;
-    if (typeof v === "number") {
-      value = !key.match(
-        /^(?:a|border-im|column(?:-c|s)|flex(?:$|-[^b])|grid-(?:ar|[^a])|font-w|li|or|sca|st|ta|wido|z)|ty$/
-      ) ? `${v}px` : `${v}`;
-    } else if (typeof v === "string") {
-      if (hasUnsafeStyleValue(v)) {
-        continue;
-      }
-      value = v;
-    } else {
-      continue;
-    }
-    fn(key, value);
-  }
-};
-export {
-  isValidAttributeName,
-  isValidTagName,
-  normalizeIntrinsicElementKey,
-  styleObjectForEach
-};

package/app/node_modules/hono/dist/middleware/basic-auth/index.js

@@ -1,66 +0,0 @@
-// src/middleware/basic-auth/index.ts
-import { HTTPException } from "../../http-exception.js";
-import { auth } from "../../utils/basic-auth.js";
-import { timingSafeEqual } from "../../utils/buffer.js";
-var basicAuth = (options, ...users) => {
-  const usernamePasswordInOptions = "username" in options && "password" in options;
-  const verifyUserInOptions = "verifyUser" in options;
-  if (!(usernamePasswordInOptions || verifyUserInOptions)) {
-    throw new Error(
-      'basic auth middleware requires options for "username and password" or "verifyUser"'
-    );
-  }
-  if (!options.realm) {
-    options.realm = "Secure Area";
-  }
-  if (!options.invalidUserMessage) {
-    options.invalidUserMessage = "Unauthorized";
-  }
-  if (usernamePasswordInOptions) {
-    users.unshift({ username: options.username, password: options.password });
-  }
-  return async function basicAuth2(ctx, next) {
-    const requestUser = auth(ctx.req.raw);
-    if (requestUser) {
-      if (verifyUserInOptions) {
-        if (await options.verifyUser(requestUser.username, requestUser.password, ctx)) {
-          if (options.onAuthSuccess) {
-            await options.onAuthSuccess(ctx, requestUser.username);
-          }
-          await next();
-          return;
-        }
-      } else {
-        for (const user of users) {
-          const [usernameEqual, passwordEqual] = await Promise.all([
-            timingSafeEqual(user.username, requestUser.username, options.hashFunction),
-            timingSafeEqual(user.password, requestUser.password, options.hashFunction)
-          ]);
-          if (usernameEqual && passwordEqual) {
-            if (options.onAuthSuccess) {
-              await options.onAuthSuccess(ctx, requestUser.username);
-            }
-            await next();
-            return;
-          }
-        }
-      }
-    }
-    const status = 401;
-    const headers = {
-      "WWW-Authenticate": 'Basic realm="' + options.realm?.replace(/"/g, '\\"') + '"'
-    };
-    const responseMessage = typeof options.invalidUserMessage === "function" ? await options.invalidUserMessage(ctx) : options.invalidUserMessage;
-    const res = typeof responseMessage === "string" ? new Response(responseMessage, { status, headers }) : new Response(JSON.stringify(responseMessage), {
-      status,
-      headers: {
-        ...headers,
-        "content-type": "application/json"
-      }
-    });
-    throw new HTTPException(status, { res });
-  };
-};
-export {
-  basicAuth
-};

package/app/node_modules/hono/dist/middleware/bearer-auth/index.js

@@ -1,92 +0,0 @@
-// src/middleware/bearer-auth/index.ts
-import { HTTPException } from "../../http-exception.js";
-import { timingSafeEqual } from "../../utils/buffer.js";
-var TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
-var PREFIX = "Bearer";
-var HEADER = "Authorization";
-var bearerAuth = (options) => {
-  if (!("token" in options || "verifyToken" in options)) {
-    throw new Error('bearer auth middleware requires options for "token" or "verifyToken"');
-  }
-  if (!options.realm) {
-    options.realm = "";
-  }
-  if (options.prefix === void 0) {
-    options.prefix = PREFIX;
-  }
-  const realm = options.realm?.replace(/"/g, '\\"');
-  const prefix = options.prefix;
-  const tokenRegexp = new RegExp(`^${TOKEN_STRINGS}$`);
-  const wwwAuthenticatePrefix = prefix === "" ? "" : `${prefix} `;
-  const throwHTTPException = async (c, status, wwwAuthenticateHeader, messageOption) => {
-    const wwwAuthenticateHeaderValue = typeof wwwAuthenticateHeader === "function" ? await wwwAuthenticateHeader(c) : wwwAuthenticateHeader;
-    const headers = {
-      "WWW-Authenticate": typeof wwwAuthenticateHeaderValue === "string" ? wwwAuthenticateHeaderValue : `${wwwAuthenticatePrefix}${Object.entries(wwwAuthenticateHeaderValue).map(([key, value]) => `${key}="${value}"`).join(",")}`
-    };
-    const responseMessage = typeof messageOption === "function" ? await messageOption(c) : messageOption;
-    const res = typeof responseMessage === "string" ? new Response(responseMessage, { status, headers }) : new Response(JSON.stringify(responseMessage), {
-      status,
-      headers: {
-        ...headers,
-        "content-type": "application/json"
-      }
-    });
-    throw new HTTPException(status, { res });
-  };
-  return async function bearerAuth2(c, next) {
-    const headerToken = c.req.header(options.headerName || HEADER);
-    if (!headerToken) {
-      await throwHTTPException(
-        c,
-        401,
-        options.noAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}realm="${realm}"`,
-        options.noAuthenticationHeader?.message || options.noAuthenticationHeaderMessage || "Unauthorized"
-      );
-    } else {
-      let tokenValue;
-      if (prefix === "") {
-        tokenValue = headerToken;
-      } else {
-        const headerLower = headerToken.toLowerCase();
-        const prefixLower = prefix.toLowerCase();
-        if (headerLower.startsWith(prefixLower) && headerToken[prefix.length] === " ") {
-          tokenValue = headerToken.slice(prefix.length).trimStart();
-        }
-      }
-      if (!tokenValue || !tokenRegexp.test(tokenValue)) {
-        await throwHTTPException(
-          c,
-          400,
-          options.invalidAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_request"`,
-          options.invalidAuthenticationHeader?.message || options.invalidAuthenticationHeaderMessage || "Bad Request"
-        );
-      } else {
-        let equal = false;
-        if ("verifyToken" in options) {
-          equal = await options.verifyToken(tokenValue, c);
-        } else if (typeof options.token === "string") {
-          equal = await timingSafeEqual(options.token, tokenValue, options.hashFunction);
-        } else if (Array.isArray(options.token) && options.token.length > 0) {
-          for (const token of options.token) {
-            if (await timingSafeEqual(token, tokenValue, options.hashFunction)) {
-              equal = true;
-              break;
-            }
-          }
-        }
-        if (!equal) {
-          await throwHTTPException(
-            c,
-            401,
-            options.invalidToken?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_token"`,
-            options.invalidToken?.message || options.invalidTokenMessage || "Unauthorized"
-          );
-        }
-      }
-    }
-    await next();
-  };
-};
-export {
-  bearerAuth
-};

package/app/node_modules/hono/dist/middleware/body-limit/index.js

@@ -1,53 +0,0 @@
-// src/middleware/body-limit/index.ts
-import { HTTPException } from "../../http-exception.js";
-var ERROR_MESSAGE = "Payload Too Large";
-var bodyLimit = (options) => {
-  const onError = options.onError || (() => {
-    const res = new Response(ERROR_MESSAGE, {
-      status: 413
-    });
-    throw new HTTPException(413, { res });
-  });
-  const maxSize = options.maxSize;
-  return async function bodyLimit2(c, next) {
-    if (!c.req.raw.body) {
-      return next();
-    }
-    const hasTransferEncoding = c.req.raw.headers.has("transfer-encoding");
-    const hasContentLength = c.req.raw.headers.has("content-length");
-    if (hasContentLength && !hasTransferEncoding) {
-      const contentLength = parseInt(c.req.raw.headers.get("content-length") || "0", 10);
-      return contentLength > maxSize ? onError(c) : next();
-    }
-    let size = 0;
-    const chunks = [];
-    const rawReader = c.req.raw.body.getReader();
-    for (; ; ) {
-      const { done, value } = await rawReader.read();
-      if (done) {
-        break;
-      }
-      size += value.length;
-      if (size > maxSize) {
-        return onError(c);
-      }
-      chunks.push(value);
-    }
-    const requestInit = {
-      body: new ReadableStream({
-        start(controller) {
-          for (const chunk of chunks) {
-            controller.enqueue(chunk);
-          }
-          controller.close();
-        }
-      }),
-      duplex: "half"
-    };
-    c.req.raw = new Request(c.req.raw, requestInit);
-    return next();
-  };
-};
-export {
-  bodyLimit
-};