TEST UPDATES

.gitignore

@@ -0,0 +1,44 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# local env files
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+*.env.*
+.env
+
+# vercel
+.vercel
+
+**/*.trace
+**/*.zip
+**/*.tar.gz
+**/*.tgz
+**/*.log
+package-lock.json
+**/*.bun

Dockerfile

@@ -0,0 +1,19 @@
+FROM oven/bun:latest
+
+# USER root
+# RUN apt-get update
+
+RUN useradd -m -u 1001 user
+WORKDIR /app
+
+COPY --chown=user package.json ./
+RUN bun install
+
+USER user
+ENV PATH="/home/user/.bun/bin:$PATH"
+
+COPY --chown=user . .
+
+EXPOSE 7860
+
+CMD ["bun", "run", "start:prod:tsdown"]

README.md

@@ -0,0 +1,15 @@
+# Elysia with Bun runtime
+
+## Getting Started
+To get started with this template, simply paste this command into your terminal:
+```bash
+bun create elysia ./elysia-example
+```
+
+## Development
+To start the development server run:
+```bash
+bun run dev
+```
+
+Open http://localhost:3000/ with your browser to see the result.

package.json

@@ -0,0 +1,32 @@
+{
+  "name": "hf-app-proxima",
+  "version": "1.0.50",
+  "private": true,
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "bun run start:dev",
+    "start:dev": "bun run --watch src/index.ts",
+    "start:dev:tsdown": "bun run --watch dist/index.mjs",
+    "prod": "bun run start:prod",
+    "start:prod": "NODE_ENV=production bun src/index.ts",
+    "start:prod:tsdown": "NODE_ENV=production bun dist/index.mjs",
+    "build:tsdown": "bun run tsdown"
+  },
+  "dependencies": {
+    "@elysiajs/cors": "^1.4.1",
+    "@elysiajs/html": "^1.4.0",
+    "@hono/standard-validator": "^0.2.2",
+    "axios": "^1.13.5",
+    "devalue": "^5.6.3",
+    "elysia": "latest",
+    "hono": "^4.12.2",
+    "html-prettify": "^1.0.7",
+    "http-errors": "^2.0.1",
+    "valibot": "^1.2.0"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "tsdown": "^0.20.3"
+  },
+  "module": "src/index.js"
+}

src/index.ts

@@ -0,0 +1,65 @@
+import { Elysia, Context, t } from "elysia";
+import { logger } from "@chneau/elysia-logger";
+import { staticPlugin } from "@elysiajs/static";
+import { cors } from "@elysiajs/cors";
+import {
+  NS_helpers_client,
+  NS_helpers_server
+} from "../../../../packages/lib/helpers/index";
+import { HonoRouter } from "./sub-router/hono.index";
+
+const APP_ENV = Bun.env.APP_ENV;
+const APP_ORIGIN = Bun.env.APP_ORIGIN;
+
+const app = new Elysia()
+
+  .use(
+    cors({
+      origin: "*",
+      allowedHeaders: "*",
+      methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+      exposeHeaders: "*"
+    })
+  )
+
+  .derive((ctx: any) => ({
+    publicOrigin: NS_helpers_server.NS_routes.elysia.F_public_origin(ctx)
+  }))
+
+  .use(logger())
+
+  .onError(async ({ code, error }) => {
+    let e_message = "";
+    if (code === "VALIDATION") {
+      e_message = error.message;
+      try {
+        e_message = JSON.parse(e_message).summary;
+      } catch (err) {}
+    }
+
+    const err_d = NS_helpers_client.NS_error.F_collect_error_status_n_message({
+      ERR: error
+    });
+
+    if (APP_ENV === "dev") {
+      console.log("\n");
+      console.log({ code, e_message, ...err_d }, "\n");
+    }
+
+    return new Response(error.toString(), {
+      status: err_d.status,
+      headers: {
+        "x-error-message": err_d.message,
+        "x-error-status": err_d.status
+      }
+    });
+  })
+
+  .mount("/", HonoRouter.fetch)
+
+  .get("/", () => "Hello Elysia")
+  .listen(7860);
+
+console.log(
+  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
+);

src/sub-router/hono.index.ts

@@ -0,0 +1,21 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+import { trimTrailingSlash } from "hono/trailing-slash";
+import { ProximaRouter } from "./proxima";
+
+const app = new Hono({ strict: true });
+
+app.use(
+  trimTrailingSlash(),
+  logger(),
+  cors({
+    origin: "*",
+    allowHeaders: ["*"],
+    exposeHeaders: ["*"]
+  })
+);
+
+app.route("/", ProximaRouter);
+
+export const HonoRouter = app;

src/sub-router/proxima.ts

@@ -0,0 +1,382 @@
+import { Hono, type Context } from "hono";
+import { proxy } from "hono/proxy";
+import * as cheerio from "cheerio";
+import { NS_promise } from "../../../../../packages/lib/helpers/client/promise";
+import { NS_routes_c } from "../../../../../packages/lib/helpers/client/route";
+import { stream } from "hono/streaming";
+import prettify from "html-prettify";
+import { NS_Misc } from "../../../../../packages/lib/helpers/client/misc";
+import { NS_playback_helper } from "../../../../../packages/lib/helpers/server/playback";
+import axios from "axios";
+import { sValidator } from "@hono/standard-validator";
+import { NS_unpack_proxima } from "../../../../../packages/lib/helpers/server/proxima/unpack";
+import { NS_error } from "../../../../../packages/lib/helpers/client/error";
+
+const APP_ENV = process.env.APP_ENV;
+const X_OFFLINE = process.env.X_OFFLINE;
+const APP_ORIGIN = process.env.APP_ORIGIN;
+const REPO_ORIGIN = process.env.REPO_ORIGIN;
+
+const sub_router = new Hono().basePath("/proxima");
+
+sub_router.get(
+  "/:proxima_endpoint/:proxima_commands?",
+  sValidator("param", NS_unpack_proxima.schema, (result, c) => {
+    if (!result.success) {
+      const message = result.error[0].message;
+      return c.text(message, 400);
+    }
+  }),
+  async (ctx) => {
+    const params = ctx.req.valid("param");
+    const query = ctx.req.query();
+
+    const REQ0 = ctx.req.url;
+    const REQ_ORIGIN = APP_ORIGIN || new URL(REQ0).origin;
+    const REQ_headers = ctx.req.raw.headers;
+
+    const { proxima_endpoint, proxima_commands } = params;
+
+    const [E_, R_] = await NS_promise.F_catch_promise({
+      promise: NS_unpack_proxima.F_unpack_proxima_endpoint_n_commands({
+        proxima_endpoint,
+        proxima_commands
+      })
+    });
+
+    if (E_) {
+      const { status, message } = NS_error.F_collect_error_status_n_message({
+        ERR: E_
+      });
+
+      return ctx.text(message, status);
+    }
+
+    const { decoded_proxy_endpoint, decoded_proxy_commands } = R_;
+
+    const iFilm_id =
+      decoded_proxy_commands?.iMovie_id || decoded_proxy_commands?.iFilm_id;
+
+    const season = decoded_proxy_commands?.season;
+    const episode = decoded_proxy_commands?.episode;
+    const cinema_quality = decoded_proxy_commands?.cinema_quality;
+
+    const og_endpoint = decoded_proxy_endpoint.href;
+
+    if (query?.ops === "raw") {
+      return ctx.json({
+        decoded_proxy_endpoint: og_endpoint,
+        decoded_proxy_commands
+      });
+    }
+
+    const req0_headers_object = Object.fromEntries(
+      (REQ_headers as any).entries()
+    );
+
+    F_handle_clean_req_headers({ avoid_cert_val: true });
+
+    function F_handle_clean_req_headers(arg0: { avoid_cert_val?: boolean }) {
+      const { avoid_cert_val } = arg0;
+
+      const has_dpx_referer =
+        decoded_proxy_commands?.headers &&
+        (decoded_proxy_commands.headers["Referer"] ||
+          decoded_proxy_commands.headers["referer"]);
+
+      const has_dpx_host =
+        decoded_proxy_commands?.headers &&
+        (decoded_proxy_commands.headers["Host"] ||
+          decoded_proxy_commands.headers["host"]);
+
+      const has_dpx_origin =
+        decoded_proxy_commands?.headers &&
+        (decoded_proxy_commands.headers["Origin"] ||
+          decoded_proxy_commands.headers["origin"]);
+
+      // delete ip headers
+      delete req0_headers_object["x-forwarded-for"];
+      delete req0_headers_object["true-client-ip"];
+      delete req0_headers_object["cf-ipcountry"];
+      delete req0_headers_object["cf-connecting-ip"];
+      delete req0_headers_object["x-request-start"];
+      delete req0_headers_object["rndr-id"];
+      delete req0_headers_object["render-proxy-ttl"];
+
+      for (const key in req0_headers_object) {
+        if (!(key in req0_headers_object)) continue;
+
+        const xx = req0_headers_object[key];
+
+        if (key?.startsWith("x-")) {
+          delete req0_headers_object[key];
+        }
+
+        if (key.toLowerCase() === "referer" && has_dpx_referer) {
+          delete req0_headers_object[key];
+        }
+
+        if (key.toLowerCase() === "host") {
+          if (has_dpx_host) {
+            delete req0_headers_object[key];
+          } else {
+            req0_headers_object[key] = decoded_proxy_endpoint!.hostname;
+          }
+        }
+
+        if (key.toLowerCase() === "origin") {
+          delete req0_headers_object[key];
+        }
+      }
+
+      if (decoded_proxy_commands?.headers) {
+        for (const key in decoded_proxy_commands.headers) {
+          if (
+            Object.prototype.hasOwnProperty.call(
+              decoded_proxy_commands.headers,
+              key
+            )
+          ) {
+            const value = decoded_proxy_commands.headers[key];
+
+            req0_headers_object[key.toLowerCase()] = value;
+          }
+        }
+      }
+    }
+
+    // 1. fetch upstream
+    const upstream = await (async () => {
+      try {
+        return await proxy(decoded_proxy_endpoint.href, {
+          headers: req0_headers_object
+        });
+      } catch (err: any) {
+        if (err?.code === "ConnectionRefused" || err?.code === "ECONNREFUSED") {
+          if (
+            !decoded_proxy_commands ||
+            !decoded_proxy_commands.ECONNREFUSED_fallback
+          )
+            return;
+
+          const ECONNREFUSED_fallback = new URL(
+            decoded_proxy_commands.ECONNREFUSED_fallback.toString()
+          );
+
+          if (
+            req0_headers_object &&
+            req0_headers_object.host &&
+            req0_headers_object.host !== ECONNREFUSED_fallback.hostname
+          ) {
+            req0_headers_object.host = ECONNREFUSED_fallback.hostname;
+          }
+
+          console.log({ ECONNREFUSED_fallback }, { req0_headers_object });
+
+          return await proxy(ECONNREFUSED_fallback.toString(), {
+            headers: req0_headers_object
+          });
+        }
+      }
+    })();
+
+    // 2. short-circuit
+    if (!upstream) {
+      return new Response("upstream undefined", {
+        status: 500
+      });
+    }
+
+    // 3. strip security headers
+
+    // 2. strip security headers
+    upstream.headers.delete("content-security-policy");
+    upstream.headers.delete("x-frame-options");
+
+    const resHeaders = new Headers(upstream.headers);
+    const resHeadersObj = Object.fromEntries((resHeaders as any).entries());
+
+    const content_type = resHeaders.get("content-type") ?? "";
+
+    if (!upstream.ok) {
+      // simply forward the response unchanged
+      return upstream;
+    }
+
+    const is_m3u8 = await NS_playback_helper.F_is_M3U8_response(upstream);
+
+    // 4. HTML rewrite
+    if (
+      !decoded_proxy_commands?.m3u8_playlist_child &&
+      content_type?.includes("text/html") &&
+      !is_m3u8
+    ) {
+      return stream(ctx, async (stream) => {
+        ctx.header("Content-Encoding", "Identity");
+
+        ctx.status(upstream.status as any);
+
+        for (const key in resHeadersObj) {
+          if (Object.prototype.hasOwnProperty.call(resHeadersObj, key)) {
+            const element = resHeadersObj[key];
+
+            ctx.header(key, element);
+          }
+        }
+
+        stream.onAbort(() => {
+          console.log("Aborted!");
+        });
+
+        await stream.write(
+          await (async () => {
+            let data = await upstream.text();
+
+            const $ = cheerio.load(data);
+
+            // fix relative href/src
+            $(`[href]`).each((i, el) => {
+              const href = $(el).attr("href")?.trim();
+              if (href && !href.startsWith("//") && !href.startsWith("http")) {
+                const new_href = NS_routes_c.F_flat_url_slash(
+                  decoded_proxy_endpoint.origin + "/" + href
+                );
+                $(el).attr("href", new_href);
+              }
+            });
+
+            $(`[src]`).each((i, el) => {
+              const src = $(el).attr("src")?.trim();
+              if (src && !src.startsWith("//") && !src.startsWith("http")) {
+                const new_src = NS_routes_c.F_flat_url_slash(
+                  decoded_proxy_endpoint.origin + "/" + src
+                );
+                $(el).attr("src", new_src);
+              }
+            });
+
+            // inject monkey-patch
+            if (
+              decoded_proxy_commands?.monkey_patch &&
+              NS_Misc.F_is_record(decoded_proxy_commands.monkey_patch)
+            ) {
+              const [ERROR, RESULT] = await NS_promise.F_catch_promise({
+                promise: axios({
+                  method: "POST",
+                  baseURL: REPO_ORIGIN,
+                  url: "/sd/monkey-patch",
+                  data: {
+                    filename: "client-monkey-patch.ts",
+                    obfuscate: true,
+                    proxy_origin:
+                      decoded_proxy_commands.monkey_patch?.alpha_proxy ||
+                      REQ_ORIGIN,
+                    monkey_config: decoded_proxy_commands.monkey_patch,
+                    use_fs: true,
+                    tool: "esbuild"
+                  }
+                })
+              });
+
+              if (ERROR) {
+                console.error({ ERROR });
+              }
+
+              const data = RESULT?.data;
+
+              if (typeof data === "string") {
+                $("head").prepend(`<script>${data}</script>`);
+              }
+            }
+
+            const rewritten = prettify($.html());
+
+            return rewritten;
+          })()
+        );
+      });
+    }
+
+    if (
+      decoded_proxy_endpoint.toString().includes(".m3u8") ||
+      content_type?.includes("application/vnd.apple.mpegurl") ||
+      content_type?.includes("application/x-mpegurl")
+    ) {
+      let m3u8_content = await upstream.text();
+
+      const [ERROR, RESULT] = await NS_promise.F_catch_promise({
+        promise: NS_playback_helper.F_transform_m3u8({
+          content: m3u8_content,
+          true_origin: decoded_proxy_endpoint.origin,
+          true_base: NS_Misc.F_remove_last_array_element({
+            arr: decoded_proxy_endpoint.pathname.split("/")
+          }).join("/"),
+          proxy_base: NS_routes_c.F_flat_url_slash(REQ_ORIGIN + "/proxima"),
+          proxima_commands: decoded_proxy_commands
+        })
+      });
+
+      m3u8_content = RESULT || m3u8_content || "";
+
+      if (query?.ops === "get-master-m3u8-resolutions") {
+        const _ = NS_playback_helper.F_extract_resolutions_from_M3U8({
+          m3u8Content: m3u8_content
+        });
+
+        const play_resolutions = _ || [];
+
+        return ctx.json({
+          resolutions: play_resolutions,
+          content: m3u8_content
+        });
+      }
+
+      if (!decoded_proxy_commands?.m3u8_playlist_child && REPO_ORIGIN) {
+        const [ERROR, RESULT] = await NS_promise.F_catch_promise({
+          promise: axios({
+            method: "POST",
+            baseURL: REPO_ORIGIN,
+            url: "/proxima/post-processing/hls",
+            data: {
+              post_data: m3u8_content,
+              proxima_endpoint: decoded_proxy_endpoint.toString(),
+              proxima_commands: decoded_proxy_commands,
+              req_headers: req0_headers_object
+            }
+          })
+        });
+
+        if (RESULT?.data) {
+          const java_set = RESULT.data["xx-java-set"];
+          const lo_java_set = RESULT.data["xx-lo-java-set"];
+
+          if (java_set) {
+            // set x-java-set header
+            ctx.header("x-java-set", java_set);
+          }
+
+          if (lo_java_set) {
+            // set xx-lo-java-set header
+            ctx.header("x-lo-java-set", lo_java_set);
+          }
+        }
+      }
+
+      ctx.status(upstream.status as any);
+
+      for (const key in resHeadersObj) {
+        if (Object.prototype.hasOwnProperty.call(resHeadersObj, key)) {
+          const element = resHeadersObj[key];
+
+          ctx.header(key, element);
+        }
+      }
+
+      return ctx.body(m3u8_content);
+    }
+
+    return upstream;
+  }
+);
+
+export const ProximaRouter = sub_router;

tsconfig.json

@@ -0,0 +1,103 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "ES2021",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "ES2022",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    "types": ["bun-types"],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}

tsdown.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: "src/index.ts",
+  shims: true,
+  tsconfig: "./tsconfig.json",
+  outDir: "dist",
+  noExternal: ["lib"],
+  external: [/^(?!\.{1,2}\/|(?:\/|\\\\|[a-zA-Z]:)).*$/]
+});