coralite 0.37.1 → 0.37.2

package/dist/lib/plugin.js

@@ -0,0 +1,147 @@
+// lib/plugin.js
+import { basename, dirname } from "path";
+
+// lib/utils/errors.js
+var CoraliteError = class extends Error {
+  /**
+   * @param {string} message - The error message.
+   * @param {Object} [options] - Additional options for the error.
+   * @param {string} [options.componentId] - The ID of the component where the error occurred.
+   * @param {string} [options.filePath] - The path to the file where the error occurred.
+   * @param {string} [options.instanceId] - The unique ID of the component instance.
+   * @param {string} [options.pagePath] - The path to the page being rendered.
+   * @param {number} [options.line] - The line number where the error occurred.
+   * @param {number} [options.column] - The column number where the error occurred.
+   * @param {string} [options.stackFile] - The file name from the stack trace.
+   * @param {Error} [options.cause] - The original error that caused this error.
+   */
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "CoraliteError";
+    this.isCoraliteError = true;
+    this.componentId = options.componentId;
+    this.filePath = options.filePath;
+    this.instanceId = options.instanceId;
+    this.pagePath = options.pagePath;
+    this.line = options.line;
+    this.column = options.column;
+    this.stackFile = options.stackFile;
+    if (options.cause && !this.cause) {
+      this.cause = options.cause;
+    }
+  }
+};
+
+// lib/plugin.js
+function validateNonEmptyString(value, paramName) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new CoraliteError(
+      `Coralite plugin validation failed: "${paramName}" must be a non-empty string, received ${typeof value}`
+    );
+  }
+}
+function validateStringArray(value, paramName) {
+  if (!Array.isArray(value)) {
+    throw new CoraliteError(
+      `Coralite plugin validation failed: "${paramName}" must be an array, received ${typeof value}`
+    );
+  }
+  for (let i = 0; i < value.length; i++) {
+    if (typeof value[i] !== "string") {
+      throw new CoraliteError(
+        `Coralite plugin validation failed: "${paramName}[${i}]" must be a string, received ${typeof value[i]}`
+      );
+    }
+  }
+}
+function processComponents(path) {
+  try {
+    const componentData = {
+      path: {
+        pathname: path,
+        dirname: dirname(path),
+        filename: basename(path)
+      }
+    };
+    return componentData;
+  } catch (error) {
+    throw new CoraliteError(
+      `Coralite plugin component processing failed for "${path}": ${error.message}`,
+      {
+        cause: error,
+        filePath: path
+      }
+    );
+  }
+}
+function definePlugin({
+  name,
+  server,
+  client
+}) {
+  validateNonEmptyString(name, "name");
+  let callerDir;
+  if (client != null && client.rootDir == null) {
+    const stack = new Error().stack;
+    if (stack) {
+      const callerLine = stack.split("\n")[2];
+      if (callerLine) {
+        const match = callerLine.match(/file:\/\/(.+?):/);
+        if (match) {
+          callerDir = dirname(match[1]);
+        }
+      }
+    }
+  }
+  if (server != null) {
+    if (typeof server !== "object") {
+      throw new CoraliteError(
+        `Coralite plugin validation failed: "server" must be an object, received ${typeof server}`
+      );
+    }
+    server = { ...server };
+    if (server.components) {
+      validateStringArray(server.components, "server.components");
+      const componentHTMLData = [];
+      try {
+        for (const path of server.components) {
+          componentHTMLData.push(processComponents(path));
+        }
+        server.components = componentHTMLData;
+      } catch (error) {
+        throw new CoraliteError(
+          `Coralite plugin "${name}" failed to load components: ${error.message}`,
+          { cause: error }
+        );
+      }
+    }
+  }
+  if (client != null) {
+    if (typeof client !== "object") {
+      throw new CoraliteError(
+        `Coralite plugin validation failed: "client" must be an object, received ${typeof client}`
+      );
+    }
+    if (client.setup != null && typeof client.setup !== "function") {
+      throw new CoraliteError(
+        `Coralite plugin validation failed: "client.setup" must be a function, received ${typeof client.setup}`
+      );
+    }
+    if (client.config != null && typeof client.config !== "object") {
+      throw new CoraliteError(
+        `Coralite plugin validation failed: "client.config" must be an object, received ${typeof client.config}`
+      );
+    }
+    client.rootDir = client.rootDir || callerDir;
+    client.name = client.name || name;
+  }
+  return {
+    name,
+    server,
+    client
+  };
+}
+export {
+  definePlugin
+};
+//# sourceMappingURL=plugin.js.map

package/dist/lib/plugin.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../lib/plugin.js", "../../lib/utils/errors.js"],
+  "sourcesContent": ["/**\n * @import { CoralitePlugin, HTMLData } from '../types/index.js'\n */\n\nimport { basename, dirname } from 'path'\nimport { CoraliteError } from './utils/errors.js'\n\n/**\n * Validates that a value is a non-empty string\n * @param {*} value - Value to validate\n * @param {string} paramName - Parameter name for error messages\n * @throws {Error} If value is not a valid non-empty string\n */\nfunction validateNonEmptyString (value, paramName) {\n  if (typeof value !== 'string' || value.trim().length === 0) {\n    throw new CoraliteError(\n      `Coralite plugin validation failed: \"${paramName}\" must be a non-empty string, received ${typeof value}`\n    )\n  }\n}\n\n/**\n * Validates that a value is an array of strings (or empty array)\n * @param {*} value - Value to validate\n * @param {string} paramName - Parameter name for error messages\n * @throws {Error} If value is defined but not an array of strings\n */\nfunction validateStringArray (value, paramName) {\n  if (!Array.isArray(value)) {\n    throw new CoraliteError(\n      `Coralite plugin validation failed: \"${paramName}\" must be an array, received ${typeof value}`\n    )\n  }\n\n  for (let i = 0; i < value.length; i++) {\n    if (typeof value[i] !== 'string') {\n      throw new CoraliteError(\n        `Coralite plugin validation failed: \"${paramName}[${i}]\" must be a string, received ${typeof value[i]}`\n      )\n    }\n  }\n}\n\n/**\n * Processes a single components file with optional caching\n * @param {string} path - Template file path\n * @returns {HTMLData} Template data\n * @throws {Error} If components file cannot be read or is invalid\n */\nfunction processComponents (path) {\n  try {\n    const componentData = {\n      path: {\n        pathname: path,\n        dirname: dirname(path),\n        filename: basename(path)\n      }\n    }\n\n    return componentData\n  } catch (error) {\n    throw new CoraliteError(\n      `Coralite plugin component processing failed for \"${path}\": ${error.message}`,\n      {\n        cause: error,\n        filePath: path\n      }\n    )\n  }\n}\n\n/**\n * Creates a new Coralite plugin instance based on provided configuration options.\n * @param {CoralitePlugin & { server?: { components?: string[] } }} options - Plugin configuration object\n * @returns {CoralitePlugin} A configured plugin instance ready to be registered with Coralite\n * @example\n * // Basic plugin\n * const myPlugin = definePlugin({\n *   name: 'my-plugin',\n *   server: {\n *     exports: {\n *       getData: (context) => (options) => {\n *         // Plugin logic implementation\n *         return { ...context.state, custom: 'data', ...options }\n *       }\n *     }\n *   }\n * })\n *\n * @example\n * // Plugin with components and metadata\n * const advancedPlugin = definePlugin({\n *   name: 'advanced-plugin',\n *   server: {\n *     exports: {\n *       process: (context) => async (options) => {\n *         // Async plugin logic\n *         return { ...context.state, processed: true, ...options }\n *       }\n *     },\n *     components: ['src/components/header.html', 'src/components/footer.html'],\n *     onPageSet: async (data) => {\n *       console.log('Page created:', data.path.pathname)\n *     }\n *   }\n * })\n */\nexport function definePlugin ({\n  name,\n  server,\n  client\n}) {\n  validateNonEmptyString(name, 'name')\n\n  let callerDir\n  if (client != null && client.rootDir == null) {\n    const stack = new Error().stack\n    if (stack) {\n      const callerLine = stack.split('\\n')[2]\n      if (callerLine) {\n        const match = callerLine.match(/file:\\/\\/(.+?):/)\n        if (match) {\n          callerDir = dirname(match[1])\n        }\n      }\n    }\n  }\n\n  // Validate server plugin if provided\n  if (server != null) {\n    if (typeof server !== 'object') {\n      throw new CoraliteError(\n        `Coralite plugin validation failed: \"server\" must be an object, received ${typeof server}`\n      )\n    }\n\n    server = { ...server }\n\n    // Process component files with error handling\n    if (server.components) {\n      validateStringArray(server.components, 'server.components')\n\n      const componentHTMLData = []\n      try {\n        // Process all components\n        for (const path of server.components) {\n          componentHTMLData.push(processComponents(path))\n        }\n        // @ts-ignore\n        server.components = componentHTMLData\n      } catch (error) {\n        // Enhance error message with plugin context\n        throw new CoraliteError(\n          `Coralite plugin \"${name}\" failed to load components: ${error.message}`,\n          { cause: error }\n        )\n      }\n    }\n  }\n\n  // Validate client plugin if provided\n  if (client != null) {\n    if (typeof client !== 'object') {\n      throw new CoraliteError(\n        `Coralite plugin validation failed: \"client\" must be an object, received ${typeof client}`\n      )\n    }\n\n    // Validate optional client state\n    if (client.setup != null && typeof client.setup !== 'function') {\n      throw new CoraliteError(\n        `Coralite plugin validation failed: \"client.setup\" must be a function, received ${typeof client.setup}`\n      )\n    }\n\n    if (client.config != null && typeof client.config !== 'object') {\n      throw new CoraliteError(\n        `Coralite plugin validation failed: \"client.config\" must be an object, received ${typeof client.config}`\n      )\n    }\n\n    // append rootDir\n    client.rootDir = client.rootDir || callerDir\n    client.name = client.name || name\n  }\n\n  // Create the plugin object with all configured state\n  return {\n    name,\n    server,\n    client\n  }\n}\n", "\n/**\n * @import { CoraliteErrorData } from '../../types/index.js'\n */\n\n/**\n * Base error class for all Coralite-related errors.\n */\nexport class CoraliteError extends Error {\n  /**\n   * @param {string} message - The error message.\n   * @param {Object} [options] - Additional options for the error.\n   * @param {string} [options.componentId] - The ID of the component where the error occurred.\n   * @param {string} [options.filePath] - The path to the file where the error occurred.\n   * @param {string} [options.instanceId] - The unique ID of the component instance.\n   * @param {string} [options.pagePath] - The path to the page being rendered.\n   * @param {number} [options.line] - The line number where the error occurred.\n   * @param {number} [options.column] - The column number where the error occurred.\n   * @param {string} [options.stackFile] - The file name from the stack trace.\n   * @param {Error} [options.cause] - The original error that caused this error.\n   */\n  constructor (message, options = {}) {\n    super(message, options)\n    this.name = 'CoraliteError'\n    this.isCoraliteError = true\n    this.componentId = options.componentId\n    this.filePath = options.filePath\n    this.instanceId = options.instanceId\n    this.pagePath = options.pagePath\n    this.line = options.line\n    this.column = options.column\n    this.stackFile = options.stackFile\n\n    // Polyfill cause if necessary (node version differences)\n    if (options.cause && !this.cause) {\n      this.cause = options.cause\n    }\n  }\n}\n\n/**\n * Default error handler.\n * @param {CoraliteErrorData} data - The data object containing error details.\n */\nexport function defaultOnError ({ level, message, error }) {\n  if (level === 'ERR') {\n    if (error) {\n      throw error\n    }\n    throw new CoraliteError(message)\n  } else if (level === 'WARN') {\n    console.warn(message)\n  } else {\n    console.log(message)\n  }\n}\n\n/**\n * Handles errors using an optional callback or the default handler.\n * @param {Object} options - The options for handling the error.\n * @param {Function} [options.onErrorCallback] - The optional custom error callback function.\n * @param {CoraliteErrorData} options.data - The error data to be handled.\n */\nexport function handleError ({ onErrorCallback, data }) {\n  const error = data.error\n  if (error && 'isCoraliteError' in error && error.isCoraliteError) {\n    const coraliteError = error\n    // @ts-ignore\n    data.componentId = data.componentId || coraliteError.componentId\n    // @ts-ignore\n    data.filePath = data.filePath || coraliteError.filePath\n    // @ts-ignore\n    data.instanceId = data.instanceId || coraliteError.instanceId\n    // @ts-ignore\n    data.pagePath = data.pagePath || coraliteError.pagePath\n    // @ts-ignore\n    data.line = data.line || coraliteError.line\n    // @ts-ignore\n    data.column = data.column || coraliteError.column\n    // @ts-ignore\n    data.stackFile = data.stackFile || coraliteError.stackFile\n  }\n\n  if (onErrorCallback) {\n    onErrorCallback(data)\n  } else {\n    defaultOnError(data)\n  }\n}\n"],
+  "mappings": ";AAIA,SAAS,UAAU,eAAe;;;ACI3B,IAAM,gBAAN,cAA4B,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAavC,YAAa,SAAS,UAAU,CAAC,GAAG;AAClC,UAAM,SAAS,OAAO;AACtB,SAAK,OAAO;AACZ,SAAK,kBAAkB;AACvB,SAAK,cAAc,QAAQ;AAC3B,SAAK,WAAW,QAAQ;AACxB,SAAK,aAAa,QAAQ;AAC1B,SAAK,WAAW,QAAQ;AACxB,SAAK,OAAO,QAAQ;AACpB,SAAK,SAAS,QAAQ;AACtB,SAAK,YAAY,QAAQ;AAGzB,QAAI,QAAQ,SAAS,CAAC,KAAK,OAAO;AAChC,WAAK,QAAQ,QAAQ;AAAA,IACvB;AAAA,EACF;AACF;;;ADzBA,SAAS,uBAAwB,OAAO,WAAW;AACjD,MAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,WAAW,GAAG;AAC1D,UAAM,IAAI;AAAA,MACR,uCAAuC,SAAS,0CAA0C,OAAO,KAAK;AAAA,IACxG;AAAA,EACF;AACF;AAQA,SAAS,oBAAqB,OAAO,WAAW;AAC9C,MAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,UAAM,IAAI;AAAA,MACR,uCAAuC,SAAS,gCAAgC,OAAO,KAAK;AAAA,IAC9F;AAAA,EACF;AAEA,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,QAAI,OAAO,MAAM,CAAC,MAAM,UAAU;AAChC,YAAM,IAAI;AAAA,QACR,uCAAuC,SAAS,IAAI,CAAC,iCAAiC,OAAO,MAAM,CAAC,CAAC;AAAA,MACvG;AAAA,IACF;AAAA,EACF;AACF;AAQA,SAAS,kBAAmB,MAAM;AAChC,MAAI;AACF,UAAM,gBAAgB;AAAA,MACpB,MAAM;AAAA,QACJ,UAAU;AAAA,QACV,SAAS,QAAQ,IAAI;AAAA,QACrB,UAAU,SAAS,IAAI;AAAA,MACzB;AAAA,IACF;AAEA,WAAO;AAAA,EACT,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,oDAAoD,IAAI,MAAM,MAAM,OAAO;AAAA,MAC3E;AAAA,QACE,OAAO;AAAA,QACP,UAAU;AAAA,MACZ;AAAA,IACF;AAAA,EACF;AACF;AAsCO,SAAS,aAAc;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AACF,GAAG;AACD,yBAAuB,MAAM,MAAM;AAEnC,MAAI;AACJ,MAAI,UAAU,QAAQ,OAAO,WAAW,MAAM;AAC5C,UAAM,QAAQ,IAAI,MAAM,EAAE;AAC1B,QAAI,OAAO;AACT,YAAM,aAAa,MAAM,MAAM,IAAI,EAAE,CAAC;AACtC,UAAI,YAAY;AACd,cAAM,QAAQ,WAAW,MAAM,iBAAiB;AAChD,YAAI,OAAO;AACT,sBAAY,QAAQ,MAAM,CAAC,CAAC;AAAA,QAC9B;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAGA,MAAI,UAAU,MAAM;AAClB,QAAI,OAAO,WAAW,UAAU;AAC9B,YAAM,IAAI;AAAA,QACR,2EAA2E,OAAO,MAAM;AAAA,MAC1F;AAAA,IACF;AAEA,aAAS,EAAE,GAAG,OAAO;AAGrB,QAAI,OAAO,YAAY;AACrB,0BAAoB,OAAO,YAAY,mBAAmB;AAE1D,YAAM,oBAAoB,CAAC;AAC3B,UAAI;AAEF,mBAAW,QAAQ,OAAO,YAAY;AACpC,4BAAkB,KAAK,kBAAkB,IAAI,CAAC;AAAA,QAChD;AAEA,eAAO,aAAa;AAAA,MACtB,SAAS,OAAO;AAEd,cAAM,IAAI;AAAA,UACR,oBAAoB,IAAI,gCAAgC,MAAM,OAAO;AAAA,UACrE,EAAE,OAAO,MAAM;AAAA,QACjB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAGA,MAAI,UAAU,MAAM;AAClB,QAAI,OAAO,WAAW,UAAU;AAC9B,YAAM,IAAI;AAAA,QACR,2EAA2E,OAAO,MAAM;AAAA,MAC1F;AAAA,IACF;AAGA,QAAI,OAAO,SAAS,QAAQ,OAAO,OAAO,UAAU,YAAY;AAC9D,YAAM,IAAI;AAAA,QACR,kFAAkF,OAAO,OAAO,KAAK;AAAA,MACvG;AAAA,IACF;AAEA,QAAI,OAAO,UAAU,QAAQ,OAAO,OAAO,WAAW,UAAU;AAC9D,YAAM,IAAI;AAAA,QACR,kFAAkF,OAAO,OAAO,MAAM;AAAA,MACxG;AAAA,IACF;AAGA,WAAO,UAAU,OAAO,WAAW;AACnC,WAAO,OAAO,OAAO,QAAQ;AAAA,EAC/B;AAGA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/lib/utils/core.js

@@ -0,0 +1,467 @@
+// lib/utils/errors.js
+var CoraliteError = class extends Error {
+  /**
+   * @param {string} message - The error message.
+   * @param {Object} [options] - Additional options for the error.
+   * @param {string} [options.componentId] - The ID of the component where the error occurred.
+   * @param {string} [options.filePath] - The path to the file where the error occurred.
+   * @param {string} [options.instanceId] - The unique ID of the component instance.
+   * @param {string} [options.pagePath] - The path to the page being rendered.
+   * @param {number} [options.line] - The line number where the error occurred.
+   * @param {number} [options.column] - The column number where the error occurred.
+   * @param {string} [options.stackFile] - The file name from the stack trace.
+   * @param {Error} [options.cause] - The original error that caused this error.
+   */
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "CoraliteError";
+    this.isCoraliteError = true;
+    this.componentId = options.componentId;
+    this.filePath = options.filePath;
+    this.instanceId = options.instanceId;
+    this.pagePath = options.pagePath;
+    this.line = options.line;
+    this.column = options.column;
+    this.stackFile = options.stackFile;
+    if (options.cause && !this.cause) {
+      this.cause = options.cause;
+    }
+  }
+};
+
+// lib/utils/core.js
+var KEBAB_REGEX = /[-|:]([a-z])/g;
+function kebabToCamel(str) {
+  return str.replace(KEBAB_REGEX, function(match, letter) {
+    return letter.toUpperCase();
+  });
+}
+function cleanKeys(object) {
+  const result = {};
+  for (const [key, value] of Object.entries(object)) {
+    result[key] = value;
+    const camelKey = kebabToCamel(key);
+    if (camelKey !== key) {
+      result[camelKey] = value;
+    }
+  }
+  return result;
+}
+function normalizeObjectFunctions(target, transform = null, seen = /* @__PURE__ */ new WeakMap()) {
+  if (typeof transform === "function") {
+    const transformed = transform(target);
+    if (transformed !== target) {
+      return transformed;
+    }
+  }
+  if (typeof target !== "object" || target === null) {
+    return target;
+  }
+  if (seen.has(target)) {
+    return seen.get(target);
+  }
+  if (Array.isArray(target)) {
+    const arr = [];
+    seen.set(target, arr);
+    for (let i = 0; i < target.length; i++) {
+      arr.push(normalizeObjectFunctions(target[i], transform, seen));
+    }
+    return arr;
+  }
+  const obj = {};
+  seen.set(target, obj);
+  for (const key in target) {
+    if (Object.hasOwn(target, key)) {
+      if (typeof target[key] === "function") {
+        const normalizedString = normalizeFunction(target[key]);
+        const originalFunction = target[key];
+        const wrapper = function() {
+          return originalFunction.apply(this, arguments);
+        };
+        wrapper.toString = () => normalizedString;
+        obj[key] = wrapper;
+      } else {
+        obj[key] = normalizeObjectFunctions(target[key], transform, seen);
+      }
+    }
+  }
+  return obj;
+}
+function hasObjectKeys(obj) {
+  return obj && typeof obj === "object" && Object.keys(obj).length > 0;
+}
+function mergeUniqueObjects(arr1, arr2) {
+  const all = [...arr1 || [], ...arr2 || []];
+  const seen = /* @__PURE__ */ new Set();
+  return all.filter((item) => {
+    const key = typeof item === "object" ? JSON.stringify(item) : item;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+function normalizeFunction(func) {
+  const original = func.toString().trim();
+  const firstBrace = original.indexOf("{");
+  const firstArrow = original.indexOf("=>");
+  const isArrow = firstArrow !== -1 && (firstBrace === -1 || firstArrow < firstBrace);
+  if (isArrow) {
+    return original;
+  }
+  const header = firstBrace !== -1 ? original.slice(0, firstBrace).trim() : original;
+  const isStandard = header.startsWith("function") || header.startsWith("async function");
+  if (isStandard) {
+    return original;
+  }
+  if (header.startsWith("async ")) {
+    if (header.startsWith("async get ") || header.startsWith("async set ")) {
+      return original;
+    }
+    return original.replace(/^async\s+([$\w]+)\s*\(/, "async function(");
+  } else {
+    if (header.startsWith("get ") || header.startsWith("set ")) {
+      return original;
+    }
+    return original.replace(/^([$\w]+)\s*\(/, "function(");
+  }
+}
+function cloneNode(nodeMap, node, parent) {
+  const newNode = Object.create(Object.getPrototypeOf(node));
+  Object.assign(newNode, node);
+  if (parent) {
+    newNode.parent = parent;
+  }
+  if (newNode.attribs) {
+    newNode.attribs = { ...newNode.attribs };
+  }
+  nodeMap.set(node, newNode);
+  if (node.children) {
+    const children = node.children;
+    const length = children.length;
+    const clonedChildren = new Array(length);
+    newNode.children = clonedChildren;
+    for (let i = 0; i < length; i++) {
+      const clonedChild = cloneNode(nodeMap, children[i], newNode);
+      clonedChildren[i] = clonedChild;
+      if (i > 0) {
+        clonedChild.prev = clonedChildren[i - 1];
+        clonedChildren[i - 1].next = clonedChild;
+      }
+    }
+  }
+  if (node.slots) {
+    const slots = node.slots;
+    const length = slots.length;
+    const clonedSlots = new Array(length);
+    for (let i = 0; i < length; i++) {
+      const slot = slots[i];
+      const clonedSlot = { ...slot };
+      if (slot.node) {
+        const clonedNode = nodeMap.get(slot.node);
+        if (clonedNode) {
+          clonedSlot.node = clonedNode;
+        }
+      }
+      clonedSlots[i] = clonedSlot;
+    }
+    newNode.slots = clonedSlots;
+  }
+  Object.defineProperty(newNode, "__coralite_enhanced__", {
+    value: true,
+    enumerable: false,
+    configurable: true
+  });
+  return newNode;
+}
+function cloneModuleInstance(originalModule) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const newTemplate = cloneNode(nodeMap, originalModule.template, null);
+  const newValues = {
+    attributes: originalModule.values.attributes.map((item) => ({
+      ...item,
+      element: nodeMap.get(item.element)
+    })),
+    textNodes: originalModule.values.textNodes.map((item) => ({
+      ...item,
+      textNode: nodeMap.get(item.textNode)
+    })),
+    refs: originalModule.values.refs.map((item) => ({
+      ...item,
+      element: nodeMap.get(item.element)
+    }))
+  };
+  const newCustomElements = originalModule.customElements.map((el) => nodeMap.get(el));
+  const newSlotElements = {};
+  if (originalModule.slotElements) {
+    for (const modId in originalModule.slotElements) {
+      newSlotElements[modId] = {};
+      const slotGroup = originalModule.slotElements[modId];
+      for (const slotName in slotGroup) {
+        const slotItem = slotGroup[slotName];
+        newSlotElements[modId][slotName] = {
+          ...slotItem,
+          element: nodeMap.get(slotItem.element)
+        };
+      }
+    }
+  }
+  return {
+    ...originalModule,
+    template: newTemplate,
+    values: newValues,
+    customElements: newCustomElements,
+    // @ts-ignore
+    slotElements: newSlotElements
+  };
+}
+function cloneComponentInstance(originalDocument) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const newRoot = cloneNode(nodeMap, originalDocument.root, null);
+  const newCustomElements = originalDocument.customElements.map((el) => nodeMap.get(el));
+  const newTempElements = originalDocument.tempElements ? originalDocument.tempElements.map((el) => nodeMap.get(el)) : [];
+  const newSkipRenderElements = originalDocument.skipRenderElements ? originalDocument.skipRenderElements.map((el) => nodeMap.get(el)) : [];
+  return {
+    ...originalDocument,
+    state: { ...originalDocument.state },
+    root: newRoot,
+    customElements: newCustomElements,
+    tempElements: newTempElements,
+    skipRenderElements: newSkipRenderElements
+  };
+}
+function getNodePath(node, root) {
+  const path = [];
+  let current = node;
+  while (current && current !== root) {
+    const parent = current.parent;
+    if (!parent) {
+      break;
+    }
+    const index = parent.children.indexOf(current);
+    if (index === -1) {
+      break;
+    }
+    path.unshift(index);
+    current = parent;
+  }
+  return path;
+}
+function generateHydrationMap(templateNodes, templateValues) {
+  const map = {
+    texts: [],
+    attributes: [],
+    refs: []
+  };
+  if (!templateNodes || !templateValues) {
+    return map;
+  }
+  const root = templateNodes.length > 0 ? templateNodes[0].parent : { children: templateNodes };
+  if (templateValues.textNodes) {
+    for (const item of templateValues.textNodes) {
+      if (item.textNode) {
+        const isHtml = item.type === "html";
+        const targetNode = isHtml ? item.textNode.parent : item.textNode;
+        map.texts.push({
+          path: getNodePath(targetNode, root),
+          template: item.textNode.data,
+          type: isHtml ? "html" : "text"
+        });
+      }
+    }
+  }
+  if (templateValues.attributes) {
+    for (const item of templateValues.attributes) {
+      if (item.element && item.element.attribs) {
+        const originalValue = item.element.attribs[item.name];
+        map.attributes.push({
+          path: getNodePath(item.element, root),
+          name: item.name,
+          template: originalValue
+        });
+      }
+    }
+  }
+  if (templateValues.refs) {
+    for (const item of templateValues.refs) {
+      if (item.element) {
+        map.refs.push({
+          path: getNodePath(item.element, root),
+          name: item.name
+        });
+      }
+    }
+  }
+  return map;
+}
+function addComponentAndDependencies(componentId, processed, sharedFunctions) {
+  if (!processed[componentId] && sharedFunctions[componentId]) {
+    processed[componentId] = true;
+    const dependencies = sharedFunctions[componentId].components || [];
+    for (const depId of dependencies) {
+      addComponentAndDependencies(depId, processed, sharedFunctions);
+    }
+  }
+}
+function cleanAST(nodes, nodeMap, state) {
+  if (!nodes) {
+    return null;
+  }
+  return nodes.map((node) => {
+    const cloned = { ...node };
+    const id = state.counter++;
+    nodeMap.set(node, id);
+    cloned._id = id;
+    delete cloned.parent;
+    delete cloned.prev;
+    delete cloned.next;
+    delete cloned.slots;
+    if (cloned.children) {
+      cloned.children = cleanAST(cloned.children, nodeMap, state);
+    }
+    return cloned;
+  });
+}
+function cleanValues(values, nodeMap) {
+  if (!values) {
+    return null;
+  }
+  const result = { ...values };
+  if (result.attributes) {
+    result.attributes = result.attributes.map((item) => {
+      const cloned = { ...item };
+      cloned.elementId = nodeMap.get(item.element);
+      delete cloned.element;
+      return cloned;
+    });
+  }
+  if (result.textNodes) {
+    result.textNodes = result.textNodes.map((item) => {
+      const cloned = { ...item };
+      cloned.textNodeId = nodeMap.get(item.textNode);
+      delete cloned.textNode;
+      return cloned;
+    });
+  }
+  if (result.refs) {
+    result.refs = result.refs.map((item) => {
+      const cloned = { ...item };
+      cloned.elementId = nodeMap.get(item.element);
+      delete cloned.element;
+      return cloned;
+    });
+  }
+  return result;
+}
+function mergePluginState(current, patch) {
+  if (!patch || typeof patch !== "object") {
+    return current;
+  }
+  const result = { ...current };
+  for (const key of Object.keys(patch)) {
+    const patchValue = patch[key];
+    const currentValue = result[key];
+    if (patchValue && typeof patchValue === "object" && !Array.isArray(patchValue) && currentValue && typeof currentValue === "object" && !Array.isArray(currentValue)) {
+      result[key] = mergePluginState(currentValue, patchValue);
+    } else {
+      result[key] = patchValue;
+    }
+  }
+  return result;
+}
+function createReactiveProxy(target, onChange, proxies = /* @__PURE__ */ new WeakMap()) {
+  if (proxies.has(target)) {
+    return proxies.get(target);
+  }
+  const handler = {
+    get(target2, property, receiver) {
+      const value = Reflect.get(target2, property, receiver);
+      if (value !== null && typeof value === "object" && !(typeof Node !== "undefined" && value instanceof Node)) {
+        return createReactiveProxy(value, onChange, proxies);
+      }
+      return value;
+    },
+    set(target2, property, value, receiver) {
+      const oldValue = target2[property];
+      if (oldValue === value && property in target2) {
+        return true;
+      }
+      const result = Reflect.set(target2, property, value, receiver);
+      if (result) {
+        onChange({
+          property,
+          value,
+          oldValue,
+          target: target2
+        });
+      }
+      return result;
+    },
+    deleteProperty(target2, property) {
+      const hadProperty = Object.prototype.hasOwnProperty.call(target2, property);
+      const oldValue = target2[property];
+      const result = Reflect.deleteProperty(target2, property);
+      if (result && hadProperty) {
+        onChange({
+          property,
+          value: void 0,
+          oldValue,
+          target: target2,
+          deleted: true
+        });
+      }
+      return result;
+    }
+  };
+  const proxy = new Proxy(target, handler);
+  proxies.set(target, proxy);
+  return proxy;
+}
+function createReadOnlyProxy(target, proxies = /* @__PURE__ */ new WeakMap()) {
+  if (proxies.has(target)) {
+    return proxies.get(target);
+  }
+  const handler = {
+    get(target2, property, receiver) {
+      const value = Reflect.get(target2, property, receiver);
+      if (value !== null && typeof value === "object" && !(typeof Node !== "undefined" && value instanceof Node)) {
+        return createReadOnlyProxy(value, proxies);
+      }
+      return value;
+    },
+    set() {
+      throw new CoraliteError("Cannot mutate state inside a getter. State is read-only here.");
+    },
+    deleteProperty() {
+      throw new CoraliteError("Cannot delete state inside a getter. State is read-only here.");
+    }
+  };
+  const proxy = new Proxy(target, handler);
+  proxies.set(target, proxy);
+  return proxy;
+}
+function defineComponent(options) {
+  return options;
+}
+export {
+  addComponentAndDependencies,
+  cleanAST,
+  cleanKeys,
+  cleanValues,
+  cloneComponentInstance,
+  cloneModuleInstance,
+  cloneNode,
+  createReactiveProxy,
+  createReadOnlyProxy,
+  defineComponent,
+  generateHydrationMap,
+  getNodePath,
+  hasObjectKeys,
+  kebabToCamel,
+  mergePluginState,
+  mergeUniqueObjects,
+  normalizeFunction,
+  normalizeObjectFunctions
+};
+//# sourceMappingURL=core.js.map