@cedarjs/prerender 7.0.0-canary.3259 → 7.0.0-rc.123

package/dist/cjs/browserUtils/index.js

@@ -0,0 +1,47 @@
+"use strict";
+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 browserUtils_exports = {};
+__export(browserUtils_exports, {
+  BrowserOnly: () => BrowserOnly,
+  isBrowser: () => isBrowser,
+  isPrerendering: () => isPrerendering,
+  useIsBrowser: () => useIsBrowser
+});
+module.exports = __toCommonJS(browserUtils_exports);
+var import_react = require("react");
+const isPrerendering = () => {
+  return globalThis.__REDWOOD__PRERENDERING ?? false;
+};
+const isBrowser = !isPrerendering();
+const useIsBrowser = () => {
+  return (0, import_react.useMemo)(() => {
+    return !globalThis?.__REDWOOD__PRERENDERING;
+  }, []);
+};
+const BrowserOnly = ({ children }) => {
+  const isBrowser2 = useIsBrowser();
+  return isBrowser2 ? children : null;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserOnly,
+  isBrowser,
+  isPrerendering,
+  useIsBrowser
+});

package/dist/cjs/build-and-import/buildAndImport.js

@@ -0,0 +1,193 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var buildAndImport_exports = {};
+__export(buildAndImport_exports, {
+  buildAndImport: () => buildAndImport
+});
+module.exports = __toCommonJS(buildAndImport_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_plugin_alias = __toESM(require("@rollup/plugin-alias"), 1);
+var import_plugin_commonjs = __toESM(require("@rollup/plugin-commonjs"), 1);
+var import_plugin_node_resolve = require("@rollup/plugin-node-resolve");
+var import_plugin_replace = __toESM(require("@rollup/plugin-replace"), 1);
+var import_rollup = require("rollup");
+var import_rollup_plugin_swc3 = require("rollup-plugin-swc3");
+var import_unplugin = __toESM(require("unimport/unplugin"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_internal = require("../internal.js");
+var import_rollup_plugin_cedar_remove_dev_fatal_error_page = require("./rollupPlugins/rollup-plugin-cedar-remove-dev-fatal-error-page.js");
+var import_rollup_plugin_cedarjs_cell = require("./rollupPlugins/rollup-plugin-cedarjs-cell.js");
+var import_rollup_plugin_cedarjs_directory_named_imports = require("./rollupPlugins/rollup-plugin-cedarjs-directory-named-imports.js");
+var import_rollup_plugin_cedarjs_external = require("./rollupPlugins/rollup-plugin-cedarjs-external.js");
+var import_rollup_plugin_cedarjs_ignore_html_and_css_imports = require("./rollupPlugins/rollup-plugin-cedarjs-ignore-html-and-css-imports.js");
+var import_rollup_plugin_cedarjs_inject_file_globals = require("./rollupPlugins/rollup-plugin-cedarjs-inject-file-globals.js");
+var import_rollup_plugin_cedarjs_prerender_media_imports = require("./rollupPlugins/rollup-plugin-cedarjs-prerender-media-imports.js");
+var import_rollup_plugin_cedarjs_routes_auto_loader = require("./rollupPlugins/rollup-plugin-cedarjs-routes-auto-loader.js");
+var import_utils = require("./utils.js");
+const fix = (f) => f;
+const tsconfigPathsToRegExp = (paths) => {
+  return Object.keys(paths || {}).map((key) => {
+    return new RegExp(`^${key.replace(/\*/g, ".*")}$`);
+  });
+};
+async function buildAndImport(options) {
+  if (!(0, import_utils.isValidJsFile)(options.filepath)) {
+    throw new Error(`${options.filepath} is not a valid JS file`);
+  }
+  const tsConfigs = (0, import_internal.parseTypeScriptConfigFiles)();
+  const resolvePaths = tsconfigPathsToRegExp(
+    tsConfigs.web?.compilerOptions?.paths || {}
+  );
+  const config = (0, import_project_config.getConfig)();
+  const useTrustedDocumentsGqlTag = config.graphql.trustedDocuments;
+  const webBase = (0, import_project_config.getPaths)().web.base;
+  const outDir = import_node_path.default.join((0, import_project_config.getPaths)().web.dist, "__prerender");
+  if (!import_node_fs.default.existsSync(outDir)) {
+    import_node_fs.default.mkdirSync(outDir, { recursive: true });
+  }
+  const isEsm = (0, import_project_config.projectIsEsm)();
+  const build = await (0, import_rollup.rollup)({
+    input: [options.filepath],
+    output: {
+      dir: outDir
+    },
+    jsx: "react-jsx",
+    logLevel: "debug",
+    external: ["react", "react-dom"],
+    plugins: [
+      (0, import_rollup_plugin_cedarjs_external.externalPlugin)({
+        notExternal: resolvePaths,
+        filepath: options.filepath
+      }),
+      (0, import_plugin_node_resolve.nodeResolve)({
+        preferBuiltins: true,
+        exportConditions: ["node"],
+        extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"]
+      }),
+      // @ts-expect-error - Ignore type errors for now
+      (0, import_plugin_replace.default)({
+        preventAssignment: true,
+        "process.env.NODE_ENV": '"production"'
+      }),
+      fix(import_plugin_alias.default)({
+        entries: [
+          {
+            find: "src",
+            replacement: (0, import_project_config.getPaths)().web.src
+          },
+          {
+            find: "$api",
+            replacement: (0, import_project_config.getPaths)().api.base
+          },
+          ...(0, import_internal.getPathsFromTypeScriptConfig)(tsConfigs.web, webBase)
+        ]
+      }),
+      // Handle JSON imports (e.g. .cedar/gqlorm-schema.json)
+      {
+        name: "json",
+        transform(code, id) {
+          if (!id.endsWith(".json")) {
+            return null;
+          }
+          try {
+            const parsed = JSON.parse(code);
+            return {
+              code: `export default ${JSON.stringify(parsed)}`,
+              map: { mappings: "" }
+            };
+          } catch {
+            return null;
+          }
+        }
+      },
+      (0, import_rollup_plugin_cedar_remove_dev_fatal_error_page.cedarRemoveDevFatalErrorPagePlugin)(),
+      (0, import_rollup_plugin_cedarjs_ignore_html_and_css_imports.ignoreHtmlAndCssImportsPlugin)(),
+      (0, import_rollup_plugin_cedarjs_cell.cellTransformPlugin)(),
+      (0, import_rollup_plugin_cedarjs_routes_auto_loader.cedarjsRoutesAutoLoaderPlugin)(),
+      (0, import_rollup_plugin_cedarjs_directory_named_imports.cedarjsDirectoryNamedImportPlugin)(),
+      (0, import_rollup_plugin_cedarjs_prerender_media_imports.cedarjsPrerenderMediaImportsPlugin)(),
+      fix(import_plugin_commonjs.default)(),
+      (0, import_rollup_plugin_swc3.swc)({ sourceMaps: true }),
+      import_unplugin.default.rollup({
+        imports: [
+          // import React from 'react'
+          {
+            name: "default",
+            as: "React",
+            from: "react"
+          },
+          // import { gql } from 'graphql-tag'
+          !useTrustedDocumentsGqlTag && isEsm && {
+            name: "gql",
+            from: "graphql-tag"
+          },
+          // import gql from 'graphql-tag'
+          !useTrustedDocumentsGqlTag && !isEsm && {
+            name: "default",
+            as: "gql",
+            from: "graphql-tag"
+          },
+          // import { gql } from 'src/graphql/gql'
+          useTrustedDocumentsGqlTag && {
+            name: "gql",
+            from: `src/graphql/gql.js`
+          }
+        ].filter((v) => Boolean(v))
+      }),
+      (0, import_rollup_plugin_cedarjs_inject_file_globals.injectFileGlobalsPlugin)()
+    ]
+  });
+  try {
+    const { output } = await build.generate({
+      dir: outDir,
+      format: (0, import_utils.getPkgType)() === "module" ? "es" : "cjs",
+      exports: "auto",
+      sourcemap: "inline"
+    });
+    for (const chunk of output) {
+      if (chunk.type !== "chunk") {
+        throw new Error("[bundle-require] Expected chunk output");
+      }
+      const chunkPath = import_node_path.default.join(outDir, chunk.fileName);
+      await import_node_fs.default.promises.writeFile(chunkPath, chunk.code, "utf8");
+    }
+    const importPath = (0, import_utils.makeFilePath)(import_node_path.default.join(outDir, output[0].fileName));
+    return import(importPath);
+  } finally {
+    if (!options.preserveTemporaryFile) {
+      await import_node_fs.default.promises.rm(outDir, { recursive: true, force: true });
+    }
+    await build.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAndImport
+});

package/dist/cjs/build-and-import/load-tsconfig.d.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/build-and-import/rollupPlugins/rollup-plugin-cedar-remove-dev-fatal-error-page.js

@@ -0,0 +1,53 @@
+"use strict";
+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 rollup_plugin_cedar_remove_dev_fatal_error_page_exports = {};
+__export(rollup_plugin_cedar_remove_dev_fatal_error_page_exports, {
+  cedarRemoveDevFatalErrorPagePlugin: () => cedarRemoveDevFatalErrorPagePlugin
+});
+module.exports = __toCommonJS(rollup_plugin_cedar_remove_dev_fatal_error_page_exports);
+const DEV_FATAL_ERROR_PAGE_MODULE = "@cedarjs/web/dist/components/DevFatalErrorPage";
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const ESCAPED_MODULE = escapeRegExp(DEV_FATAL_ERROR_PAGE_MODULE);
+const IMPORT_PATTERN = new RegExp(
+  `import\\s*\\{[^}]*\\bDevFatalErrorPage\\b[^}]*\\}\\s*from\\s*['"]${ESCAPED_MODULE}['"]`
+);
+const cedarRemoveDevFatalErrorPagePlugin = () => {
+  return {
+    name: "cedar-remove-dev-fatal-error-page",
+    transform(code) {
+      if (!code.includes(DEV_FATAL_ERROR_PAGE_MODULE)) {
+        return null;
+      }
+      const newCode = code.replace(
+        IMPORT_PATTERN,
+        "const DevFatalErrorPage = undefined"
+      );
+      if (newCode === code) {
+        return null;
+      }
+      return { code: newCode, map: null };
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarRemoveDevFatalErrorPagePlugin
+});

package/dist/cjs/build-and-import/rollupPlugins/rollup-plugin-cedarjs-cell.js

@@ -0,0 +1,184 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rollup_plugin_cedarjs_cell_exports = {};
+__export(rollup_plugin_cedarjs_cell_exports, {
+  cellTransformPlugin: () => cellTransformPlugin
+});
+module.exports = __toCommonJS(rollup_plugin_cedarjs_cell_exports);
+var import_node_path = require("node:path");
+var import_generator = __toESM(require("@babel/generator"), 1);
+var import_parser = require("@babel/parser");
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+const traverse = import_traverse.default.default;
+const generate = import_generator.default.default;
+const EXPECTED_EXPORTS_FROM_CELL = [
+  "beforeQuery",
+  "QUERY",
+  "FRAGMENT",
+  "data",
+  "isEmpty",
+  "afterQuery",
+  "Loading",
+  "Success",
+  "Failure",
+  "Empty"
+];
+function cellTransformPlugin() {
+  return {
+    name: "cedar-cell-transform",
+    transform(code, id) {
+      if (!id.match(/Cell\.[jt]sx?$/)) {
+        return null;
+      }
+      try {
+        const ast = (0, import_parser.parse)(code, {
+          sourceType: "module",
+          plugins: [
+            "jsx",
+            "typescript",
+            "decorators-legacy",
+            "classProperties",
+            "objectRestSpread",
+            "asyncGenerators",
+            "functionBind",
+            "exportDefaultFrom",
+            "exportNamespaceFrom",
+            "dynamicImport",
+            "nullishCoalescingOperator",
+            "optionalChaining"
+          ]
+        });
+        const exportNames = [];
+        let hasDefaultExport = false;
+        traverse(ast, {
+          ExportDefaultDeclaration() {
+            hasDefaultExport = true;
+          },
+          ExportNamedDeclaration(path) {
+            const declaration = path.node.declaration;
+            if (!declaration) {
+              return;
+            }
+            let name;
+            if (declaration.type === "VariableDeclaration") {
+              const id2 = declaration.declarations[0].id;
+              name = id2.name;
+            }
+            if (declaration.type === "FunctionDeclaration") {
+              name = declaration?.id?.name;
+            }
+            if (name && EXPECTED_EXPORTS_FROM_CELL.includes(name)) {
+              exportNames.push(name);
+            }
+          }
+        });
+        const hasQueryOrDataExport = exportNames.includes("QUERY") || exportNames.includes("FRAGMENT") || exportNames.includes("data");
+        if (hasDefaultExport || !hasQueryOrDataExport) {
+          return null;
+        }
+        const createCellHookName = exportNames.includes("data") ? "createServerCell" : "createCell";
+        const importFrom = exportNames.includes("data") ? "@cedarjs/web/dist/components/cell/createServerCell" : "@cedarjs/web";
+        traverse(ast, {
+          Program(path) {
+            const importDeclaration = {
+              type: "ImportDeclaration",
+              specifiers: [
+                {
+                  type: "ImportSpecifier",
+                  imported: {
+                    type: "Identifier",
+                    name: createCellHookName
+                  },
+                  local: {
+                    type: "Identifier",
+                    name: createCellHookName
+                  }
+                }
+              ],
+              source: { type: "StringLiteral", value: importFrom }
+            };
+            path.node.body.unshift(importDeclaration);
+            const objectProperties = [
+              ...exportNames.map((name) => ({
+                type: "ObjectProperty",
+                key: { type: "Identifier", name },
+                value: { type: "Identifier", name },
+                shorthand: true,
+                computed: false
+              })),
+              // Add the displayName property
+              {
+                type: "ObjectProperty",
+                key: { type: "Identifier", name: "displayName" },
+                value: {
+                  type: "StringLiteral",
+                  value: (0, import_node_path.parse)(id).name
+                },
+                shorthand: false,
+                computed: false
+              }
+            ];
+            const exportDefaultDeclaration = {
+              type: "ExportDefaultDeclaration",
+              declaration: {
+                type: "CallExpression",
+                callee: {
+                  type: "Identifier",
+                  name: createCellHookName
+                },
+                arguments: [
+                  {
+                    type: "ObjectExpression",
+                    properties: objectProperties
+                  }
+                ]
+              }
+            };
+            path.node.body.push(exportDefaultDeclaration);
+          }
+        });
+        const result = generate(ast, {
+          retainLines: true,
+          compact: false
+        });
+        return {
+          code: result.code,
+          map: result.map
+        };
+      } catch (error) {
+        console.warn(`Failed to transform Cell file ${id}:`, error);
+        return null;
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cellTransformPlugin
+});

package/dist/cjs/build-and-import/rollupPlugins/rollup-plugin-cedarjs-directory-named-imports.js

@@ -0,0 +1,83 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rollup_plugin_cedarjs_directory_named_imports_exports = {};
+__export(rollup_plugin_cedarjs_directory_named_imports_exports, {
+  cedarjsDirectoryNamedImportPlugin: () => cedarjsDirectoryNamedImportPlugin
+});
+module.exports = __toCommonJS(rollup_plugin_cedarjs_directory_named_imports_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_project_config = require("@cedarjs/project-config");
+function getNewPath(value, filename) {
+  const dirname = import_node_path.default.dirname(value);
+  const basename = import_node_path.default.basename(value);
+  const indexImportPath = [dirname, basename, "index"].join("/");
+  const resolvedFile = (0, import_project_config.resolveFile)(
+    import_node_path.default.resolve(import_node_path.default.dirname(filename), indexImportPath)
+  );
+  if (resolvedFile) {
+    return resolvedFile;
+  } else {
+    const dirnameImportPath = [dirname, basename, basename].join("/");
+    const dirnameResolvedFile = (0, import_project_config.resolveFile)(
+      import_node_path.default.resolve(import_node_path.default.dirname(filename), dirnameImportPath)
+    );
+    if (dirnameResolvedFile) {
+      return dirnameResolvedFile;
+    }
+  }
+  return null;
+}
+function cedarjsDirectoryNamedImportPlugin() {
+  return {
+    name: "cedarjs-directory-named-import",
+    resolveId(id, importer) {
+      if (!importer || importer.includes("/node_modules/")) {
+        return null;
+      }
+      const resolvedPath = import_node_path.default.resolve(import_node_path.default.dirname(importer), id);
+      if (import_node_fs.default.existsSync(resolvedPath)) {
+        const stats = import_node_fs.default.statSync(resolvedPath);
+        if (stats.isFile()) {
+          return null;
+        }
+      }
+      const newPath = getNewPath(id, importer);
+      if (!newPath) {
+        return null;
+      }
+      const resolvedDirnamePath = import_node_path.default.resolve(import_node_path.default.dirname(importer), newPath);
+      return resolvedDirnamePath;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarjsDirectoryNamedImportPlugin
+});

package/dist/cjs/build-and-import/rollupPlugins/rollup-plugin-cedarjs-external.js

@@ -0,0 +1,125 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rollup_plugin_cedarjs_external_exports = {};
+__export(rollup_plugin_cedarjs_external_exports, {
+  externalPlugin: () => externalPlugin
+});
+module.exports = __toCommonJS(rollup_plugin_cedarjs_external_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+const PATH_NODE_MODULES_RE = /[\/\\]node_modules[\/\\]/;
+const externalPlugin = ({
+  external,
+  notExternal,
+  filepath,
+  externalNodeModules = true
+}) => {
+  const extNodeModules = externalNodeModules ?? !filepath.match(PATH_NODE_MODULES_RE);
+  const builtinModules = /* @__PURE__ */ new Set([
+    "assert",
+    "buffer",
+    "child_process",
+    "cluster",
+    "crypto",
+    "dgram",
+    "dns",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "https",
+    "net",
+    "os",
+    "path",
+    "punycode",
+    "querystring",
+    "readline",
+    "stream",
+    "string_decoder",
+    "tls",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "zlib",
+    "constants",
+    "sys",
+    "module",
+    "process",
+    "inspector",
+    "async_hooks",
+    "http2",
+    "perf_hooks",
+    "trace_events",
+    "worker_threads",
+    "repl",
+    "timers"
+  ]);
+  return {
+    name: "bundle-require:external",
+    resolveId(id, importer) {
+      if (builtinModules.has(id) || id.startsWith("node:")) {
+        return { id, external: true };
+      }
+      if (match(id, external)) {
+        return { id, external: true };
+      }
+      if (match(id, notExternal)) {
+        return null;
+      }
+      if (extNodeModules && id.match(PATH_NODE_MODULES_RE)) {
+        const resolved = id.startsWith(".") && importer ? import_node_path.default.resolve(import_node_path.default.dirname(importer), id) : id;
+        return {
+          id: (0, import_node_url.pathToFileURL)(resolved).toString(),
+          external: true
+        };
+      }
+      if (id.startsWith(".") || import_node_path.default.isAbsolute(id)) {
+        return null;
+      }
+      return { id, external: true };
+    }
+  };
+};
+function match(id, patterns) {
+  if (!patterns) {
+    return false;
+  }
+  return patterns.some((p) => {
+    if (p instanceof RegExp) {
+      return p.test(id);
+    }
+    return id === p || id.startsWith(p + "/");
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  externalPlugin
+});