cms-renderer 0.2.9 → 0.3.1

package/dist/lib/custom-schemas.js

@@ -0,0 +1,1389 @@
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+// ../../node_modules/ret/dist/types/tokens.js
+var require_tokens = __commonJS({
+  "../../node_modules/ret/dist/types/tokens.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ret/dist/types/types.js
+var require_types = __commonJS({
+  "../../node_modules/ret/dist/types/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.types = void 0;
+    var types;
+    (function(types2) {
+      types2[types2["ROOT"] = 0] = "ROOT";
+      types2[types2["GROUP"] = 1] = "GROUP";
+      types2[types2["POSITION"] = 2] = "POSITION";
+      types2[types2["SET"] = 3] = "SET";
+      types2[types2["RANGE"] = 4] = "RANGE";
+      types2[types2["REPETITION"] = 5] = "REPETITION";
+      types2[types2["REFERENCE"] = 6] = "REFERENCE";
+      types2[types2["CHAR"] = 7] = "CHAR";
+    })(types = exports.types || (exports.types = {}));
+  }
+});
+
+// ../../node_modules/ret/dist/types/set-lookup.js
+var require_set_lookup = __commonJS({
+  "../../node_modules/ret/dist/types/set-lookup.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ret/dist/types/index.js
+var require_types2 = __commonJS({
+  "../../node_modules/ret/dist/types/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_tokens(), exports);
+    __exportStar(require_types(), exports);
+    __exportStar(require_set_lookup(), exports);
+  }
+});
+
+// ../../node_modules/ret/dist/sets.js
+var require_sets = __commonJS({
+  "../../node_modules/ret/dist/sets.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.anyChar = exports.notWhitespace = exports.whitespace = exports.notInts = exports.ints = exports.notWords = exports.words = void 0;
+    var types_1 = require_types2();
+    var INTS = () => [{ type: types_1.types.RANGE, from: 48, to: 57 }];
+    var WORDS = () => [
+      { type: types_1.types.CHAR, value: 95 },
+      { type: types_1.types.RANGE, from: 97, to: 122 },
+      { type: types_1.types.RANGE, from: 65, to: 90 },
+      { type: types_1.types.RANGE, from: 48, to: 57 }
+    ];
+    var WHITESPACE = () => [
+      { type: types_1.types.CHAR, value: 9 },
+      { type: types_1.types.CHAR, value: 10 },
+      { type: types_1.types.CHAR, value: 11 },
+      { type: types_1.types.CHAR, value: 12 },
+      { type: types_1.types.CHAR, value: 13 },
+      { type: types_1.types.CHAR, value: 32 },
+      { type: types_1.types.CHAR, value: 160 },
+      { type: types_1.types.CHAR, value: 5760 },
+      { type: types_1.types.RANGE, from: 8192, to: 8202 },
+      { type: types_1.types.CHAR, value: 8232 },
+      { type: types_1.types.CHAR, value: 8233 },
+      { type: types_1.types.CHAR, value: 8239 },
+      { type: types_1.types.CHAR, value: 8287 },
+      { type: types_1.types.CHAR, value: 12288 },
+      { type: types_1.types.CHAR, value: 65279 }
+    ];
+    var NOTANYCHAR = () => [
+      { type: types_1.types.CHAR, value: 10 },
+      { type: types_1.types.CHAR, value: 13 },
+      { type: types_1.types.CHAR, value: 8232 },
+      { type: types_1.types.CHAR, value: 8233 }
+    ];
+    exports.words = () => ({ type: types_1.types.SET, set: WORDS(), not: false });
+    exports.notWords = () => ({ type: types_1.types.SET, set: WORDS(), not: true });
+    exports.ints = () => ({ type: types_1.types.SET, set: INTS(), not: false });
+    exports.notInts = () => ({ type: types_1.types.SET, set: INTS(), not: true });
+    exports.whitespace = () => ({ type: types_1.types.SET, set: WHITESPACE(), not: false });
+    exports.notWhitespace = () => ({ type: types_1.types.SET, set: WHITESPACE(), not: true });
+    exports.anyChar = () => ({ type: types_1.types.SET, set: NOTANYCHAR(), not: true });
+  }
+});
+
+// ../../node_modules/ret/dist/util.js
+var require_util = __commonJS({
+  "../../node_modules/ret/dist/util.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.tokenizeClass = exports.strToChars = void 0;
+    var types_1 = require_types2();
+    var sets = __importStar(require_sets());
+    var CTRL = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ ?";
+    exports.strToChars = (str) => {
+      const charsRegex = /(\[\\b\])|(\\)?\\(?:u([A-F0-9]{4})|x([A-F0-9]{2})|c([@A-Z[\\\]^?])|([0tnvfr]))/g;
+      return str.replace(charsRegex, (s, b, lbs, a16, b16, dctrl, eslsh) => {
+        if (lbs) {
+          return s;
+        }
+        let code = b ? 8 : a16 ? parseInt(a16, 16) : b16 ? parseInt(b16, 16) : dctrl ? CTRL.indexOf(dctrl) : {
+          0: 0,
+          t: 9,
+          n: 10,
+          v: 11,
+          f: 12,
+          r: 13
+        }[eslsh];
+        let c = String.fromCharCode(code);
+        return /[[\]{}^$.|?*+()]/.test(c) ? `\\${c}` : c;
+      });
+    };
+    exports.tokenizeClass = (str, regexpStr) => {
+      var _a, _b, _c, _d, _e, _f, _g;
+      let tokens = [], rs, c;
+      const regexp = /\\(?:(w)|(d)|(s)|(W)|(D)|(S))|((?:(?:\\)(.)|([^\]\\]))-(((?:\\)])|(((?:\\)?([^\]])))))|(\])|(?:\\)?([^])/g;
+      while ((rs = regexp.exec(str)) !== null) {
+        const p = (_g = (_f = (_e = (_d = (_c = (_b = (_a = rs[1] && sets.words()) !== null && _a !== void 0 ? _a : rs[2] && sets.ints()) !== null && _b !== void 0 ? _b : rs[3] && sets.whitespace()) !== null && _c !== void 0 ? _c : rs[4] && sets.notWords()) !== null && _d !== void 0 ? _d : rs[5] && sets.notInts()) !== null && _e !== void 0 ? _e : rs[6] && sets.notWhitespace()) !== null && _f !== void 0 ? _f : rs[7] && {
+          type: types_1.types.RANGE,
+          from: (rs[8] || rs[9]).charCodeAt(0),
+          to: (c = rs[10]).charCodeAt(c.length - 1)
+        }) !== null && _g !== void 0 ? _g : (c = rs[16]) && { type: types_1.types.CHAR, value: c.charCodeAt(0) };
+        if (p) {
+          tokens.push(p);
+        } else {
+          return [tokens, regexp.lastIndex];
+        }
+      }
+      throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: Unterminated character class`);
+    };
+  }
+});
+
+// ../../node_modules/ret/dist/tokenizer.js
+var require_tokenizer = __commonJS({
+  "../../node_modules/ret/dist/tokenizer.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.tokenizer = void 0;
+    var util = __importStar(require_util());
+    var types_1 = require_types2();
+    var sets = __importStar(require_sets());
+    var captureGroupFirstChar = /^[a-zA-Z_$]$/i;
+    var captureGroupChars = /^[a-zA-Z0-9_$]$/i;
+    var digit = /\d/;
+    exports.tokenizer = (regexpStr) => {
+      let i = 0, c;
+      let start = { type: types_1.types.ROOT, stack: [] };
+      let lastGroup = start;
+      let last = start.stack;
+      let groupStack = [];
+      let referenceQueue = [];
+      let groupCount = 0;
+      const repeatErr = (col) => {
+        throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: Nothing to repeat at column ${col - 1}`);
+      };
+      let str = util.strToChars(regexpStr);
+      while (i < str.length) {
+        switch (c = str[i++]) {
+          // Handle escaped characters, inclues a few sets.
+          case "\\":
+            if (i === str.length) {
+              throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: \\ at end of pattern`);
+            }
+            switch (c = str[i++]) {
+              case "b":
+                last.push({ type: types_1.types.POSITION, value: "b" });
+                break;
+              case "B":
+                last.push({ type: types_1.types.POSITION, value: "B" });
+                break;
+              case "w":
+                last.push(sets.words());
+                break;
+              case "W":
+                last.push(sets.notWords());
+                break;
+              case "d":
+                last.push(sets.ints());
+                break;
+              case "D":
+                last.push(sets.notInts());
+                break;
+              case "s":
+                last.push(sets.whitespace());
+                break;
+              case "S":
+                last.push(sets.notWhitespace());
+                break;
+              default:
+                if (digit.test(c)) {
+                  let digits = c;
+                  while (i < str.length && digit.test(str[i])) {
+                    digits += str[i++];
+                  }
+                  let value = parseInt(digits, 10);
+                  const reference = { type: types_1.types.REFERENCE, value };
+                  last.push(reference);
+                  referenceQueue.push({ reference, stack: last, index: last.length - 1 });
+                } else {
+                  last.push({ type: types_1.types.CHAR, value: c.charCodeAt(0) });
+                }
+            }
+            break;
+          // Positionals.
+          case "^":
+            last.push({ type: types_1.types.POSITION, value: "^" });
+            break;
+          case "$":
+            last.push({ type: types_1.types.POSITION, value: "$" });
+            break;
+          // Handle custom sets.
+          case "[": {
+            let not;
+            if (str[i] === "^") {
+              not = true;
+              i++;
+            } else {
+              not = false;
+            }
+            let classTokens = util.tokenizeClass(str.slice(i), regexpStr);
+            i += classTokens[1];
+            last.push({
+              type: types_1.types.SET,
+              set: classTokens[0],
+              not
+            });
+            break;
+          }
+          // Class of any character except \n.
+          case ".":
+            last.push(sets.anyChar());
+            break;
+          // Push group onto stack.
+          case "(": {
+            let group = {
+              type: types_1.types.GROUP,
+              stack: [],
+              remember: true
+            };
+            if (str[i] === "?") {
+              c = str[i + 1];
+              i += 2;
+              if (c === "=") {
+                group.followedBy = true;
+                group.remember = false;
+              } else if (c === "!") {
+                group.notFollowedBy = true;
+                group.remember = false;
+              } else if (c === "<") {
+                let name = "";
+                if (captureGroupFirstChar.test(str[i])) {
+                  name += str[i];
+                  i++;
+                } else {
+                  throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: Invalid capture group name, character '${str[i]}' after '<' at column ${i + 1}`);
+                }
+                while (i < str.length && captureGroupChars.test(str[i])) {
+                  name += str[i];
+                  i++;
+                }
+                if (!name) {
+                  throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: Invalid capture group name, character '${str[i]}' after '<' at column ${i + 1}`);
+                }
+                if (str[i] !== ">") {
+                  throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: Unclosed capture group name, expected '>', found '${str[i]}' at column ${i + 1}`);
+                }
+                group.name = name;
+                i++;
+              } else if (c === ":") {
+                group.remember = false;
+              } else {
+                throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: Invalid group, character '${c}' after '?' at column ${i - 1}`);
+              }
+            } else {
+              groupCount += 1;
+            }
+            last.push(group);
+            groupStack.push(lastGroup);
+            lastGroup = group;
+            last = group.stack;
+            break;
+          }
+          // Pop group out of stack.
+          case ")":
+            if (groupStack.length === 0) {
+              throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: Unmatched ) at column ${i - 1}`);
+            }
+            lastGroup = groupStack.pop();
+            last = lastGroup.options ? lastGroup.options[lastGroup.options.length - 1] : lastGroup.stack;
+            break;
+          // Use pipe character to give more choices.
+          case "|": {
+            if (!lastGroup.options) {
+              lastGroup.options = [lastGroup.stack];
+              delete lastGroup.stack;
+            }
+            let stack = [];
+            lastGroup.options.push(stack);
+            last = stack;
+            break;
+          }
+          // Repetition.
+          // For every repetition, remove last element from last stack
+          // then insert back a RANGE object.
+          // This design is chosen because there could be more than
+          // one repetition symbols in a regex i.e. `a?+{2,3}`.
+          case "{": {
+            let rs = /^(\d+)(,(\d+)?)?\}/.exec(str.slice(i)), min, max;
+            if (rs !== null) {
+              if (last.length === 0) {
+                repeatErr(i);
+              }
+              min = parseInt(rs[1], 10);
+              max = rs[2] ? rs[3] ? parseInt(rs[3], 10) : Infinity : min;
+              i += rs[0].length;
+              last.push({
+                type: types_1.types.REPETITION,
+                min,
+                max,
+                value: last.pop()
+              });
+            } else {
+              last.push({
+                type: types_1.types.CHAR,
+                value: 123
+              });
+            }
+            break;
+          }
+          case "?":
+            if (last.length === 0) {
+              repeatErr(i);
+            }
+            last.push({
+              type: types_1.types.REPETITION,
+              min: 0,
+              max: 1,
+              value: last.pop()
+            });
+            break;
+          case "+":
+            if (last.length === 0) {
+              repeatErr(i);
+            }
+            last.push({
+              type: types_1.types.REPETITION,
+              min: 1,
+              max: Infinity,
+              value: last.pop()
+            });
+            break;
+          case "*":
+            if (last.length === 0) {
+              repeatErr(i);
+            }
+            last.push({
+              type: types_1.types.REPETITION,
+              min: 0,
+              max: Infinity,
+              value: last.pop()
+            });
+            break;
+          // Default is a character that is not `\[](){}?+*^$`.
+          default:
+            last.push({
+              type: types_1.types.CHAR,
+              value: c.charCodeAt(0)
+            });
+        }
+      }
+      if (groupStack.length !== 0) {
+        throw new SyntaxError(`Invalid regular expression: /${regexpStr}/: Unterminated group`);
+      }
+      updateReferences(referenceQueue, groupCount);
+      return start;
+    };
+    function updateReferences(referenceQueue, groupCount) {
+      for (const elem of referenceQueue.reverse()) {
+        if (groupCount < elem.reference.value) {
+          elem.reference.type = types_1.types.CHAR;
+          const valueString = elem.reference.value.toString();
+          elem.reference.value = parseInt(valueString, 8);
+          if (!/^[0-7]+$/.test(valueString)) {
+            let i = 0;
+            while (valueString[i] !== "8" && valueString[i] !== "9") {
+              i += 1;
+            }
+            if (i === 0) {
+              elem.reference.value = valueString.charCodeAt(0);
+              i += 1;
+            } else {
+              elem.reference.value = parseInt(valueString.slice(0, i), 8);
+            }
+            if (valueString.length > i) {
+              const tail = elem.stack.splice(elem.index + 1);
+              for (const char of valueString.slice(i)) {
+                elem.stack.push({
+                  type: types_1.types.CHAR,
+                  value: char.charCodeAt(0)
+                });
+              }
+              elem.stack.push(...tail);
+            }
+          }
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/ret/dist/sets-lookup.js
+var require_sets_lookup = __commonJS({
+  "../../node_modules/ret/dist/sets-lookup.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NOTANYCHAR = exports.WHITESPACE = exports.WORDS = exports.INTS = void 0;
+    var Sets = __importStar(require_sets());
+    var types_1 = require_types2();
+    function setToLookup(tokens) {
+      let lookup = {};
+      let len = 0;
+      for (const token of tokens) {
+        if (token.type === types_1.types.CHAR) {
+          lookup[token.value] = true;
+        }
+        if (token.type === types_1.types.RANGE) {
+          lookup[`${token.from}-${token.to}`] = true;
+        }
+        len += 1;
+      }
+      return {
+        lookup: () => Object.assign({}, lookup),
+        len
+      };
+    }
+    exports.INTS = setToLookup(Sets.ints().set);
+    exports.WORDS = setToLookup(Sets.words().set);
+    exports.WHITESPACE = setToLookup(Sets.whitespace().set);
+    exports.NOTANYCHAR = setToLookup(Sets.anyChar().set);
+  }
+});
+
+// ../../node_modules/ret/dist/write-set-tokens.js
+var require_write_set_tokens = __commonJS({
+  "../../node_modules/ret/dist/write-set-tokens.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.writeSetTokens = exports.setChar = void 0;
+    var types_1 = require_types2();
+    var sets = __importStar(require_sets_lookup());
+    function setChar(charCode) {
+      return charCode === 94 ? "\\^" : charCode === 92 ? "\\\\" : charCode === 93 ? "\\]" : charCode === 45 ? "\\-" : String.fromCharCode(charCode);
+    }
+    exports.setChar = setChar;
+    function isSameSet(set, { lookup, len }) {
+      if (len !== set.length) {
+        return false;
+      }
+      const map = lookup();
+      for (const elem of set) {
+        if (elem.type === types_1.types.SET) {
+          return false;
+        }
+        const key = elem.type === types_1.types.CHAR ? elem.value : `${elem.from}-${elem.to}`;
+        if (map[key]) {
+          map[key] = false;
+        } else {
+          return false;
+        }
+      }
+      return true;
+    }
+    function writeSetTokens(set, isNested = false) {
+      if (isSameSet(set.set, sets.INTS)) {
+        return set.not ? "\\D" : "\\d";
+      }
+      if (isSameSet(set.set, sets.WORDS)) {
+        return set.not ? "\\W" : "\\w";
+      }
+      if (set.not && isSameSet(set.set, sets.NOTANYCHAR)) {
+        return ".";
+      }
+      if (isSameSet(set.set, sets.WHITESPACE)) {
+        return set.not ? "\\S" : "\\s";
+      }
+      let tokenString = "";
+      for (let i = 0; i < set.set.length; i++) {
+        const subset = set.set[i];
+        tokenString += writeSetToken(subset);
+      }
+      const contents = `${set.not ? "^" : ""}${tokenString}`;
+      return isNested ? contents : `[${contents}]`;
+    }
+    exports.writeSetTokens = writeSetTokens;
+    function writeSetToken(set) {
+      if (set.type === types_1.types.CHAR) {
+        return setChar(set.value);
+      } else if (set.type === types_1.types.RANGE) {
+        return `${setChar(set.from)}-${setChar(set.to)}`;
+      }
+      return writeSetTokens(set, true);
+    }
+  }
+});
+
+// ../../node_modules/ret/dist/reconstruct.js
+var require_reconstruct = __commonJS({
+  "../../node_modules/ret/dist/reconstruct.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.reconstruct = void 0;
+    var types_1 = require_types2();
+    var write_set_tokens_1 = require_write_set_tokens();
+    var reduceStack = (stack) => stack.map(exports.reconstruct).join("");
+    var createAlternate = (token) => {
+      if ("options" in token) {
+        return token.options.map(reduceStack).join("|");
+      } else if ("stack" in token) {
+        return reduceStack(token.stack);
+      } else {
+        throw new Error(`options or stack must be Root or Group token`);
+      }
+    };
+    exports.reconstruct = (token) => {
+      switch (token.type) {
+        case types_1.types.ROOT:
+          return createAlternate(token);
+        case types_1.types.CHAR: {
+          const c = String.fromCharCode(token.value);
+          return (/[[\\{}$^.|?*+()]/.test(c) ? "\\" : "") + c;
+        }
+        case types_1.types.POSITION:
+          if (token.value === "^" || token.value === "$") {
+            return token.value;
+          } else {
+            return `\\${token.value}`;
+          }
+        case types_1.types.REFERENCE:
+          return `\\${token.value}`;
+        case types_1.types.SET:
+          return write_set_tokens_1.writeSetTokens(token);
+        case types_1.types.GROUP: {
+          const prefix = token.name ? `?<${token.name}>` : token.remember ? "" : token.followedBy ? "?=" : token.notFollowedBy ? "?!" : "?:";
+          return `(${prefix}${createAlternate(token)})`;
+        }
+        case types_1.types.REPETITION: {
+          const { min, max } = token;
+          let endWith;
+          if (min === 0 && max === 1) {
+            endWith = "?";
+          } else if (min === 1 && max === Infinity) {
+            endWith = "+";
+          } else if (min === 0 && max === Infinity) {
+            endWith = "*";
+          } else if (max === Infinity) {
+            endWith = `{${min},}`;
+          } else if (min === max) {
+            endWith = `{${min}}`;
+          } else {
+            endWith = `{${min},${max}}`;
+          }
+          return `${exports.reconstruct(token.value)}${endWith}`;
+        }
+        case types_1.types.RANGE:
+          return `${write_set_tokens_1.setChar(token.from)}-${write_set_tokens_1.setChar(token.to)}`;
+        default:
+          throw new Error(`Invalid token type ${token}`);
+      }
+    };
+  }
+});
+
+// ../../node_modules/ret/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/ret/dist/index.js"(exports, module) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.types = void 0;
+    var types_1 = require_types2();
+    Object.defineProperty(exports, "types", { enumerable: true, get: function() {
+      return types_1.types;
+    } });
+    __exportStar(require_tokenizer(), exports);
+    __exportStar(require_reconstruct(), exports);
+    var tokenizer_1 = require_tokenizer();
+    var reconstruct_1 = require_reconstruct();
+    __exportStar(require_types2(), exports);
+    exports.default = tokenizer_1.tokenizer;
+    module.exports = tokenizer_1.tokenizer;
+    module.exports.types = types_1.types;
+    module.exports.reconstruct = reconstruct_1.reconstruct;
+  }
+});
+
+// ../../node_modules/safe-regex2/index.js
+var require_safe_regex2 = __commonJS({
+  "../../node_modules/safe-regex2/index.js"(exports, module) {
+    "use strict";
+    var parse = require_dist();
+    var types = parse.types;
+    function safeRegex2(re, opts) {
+      if (!opts) opts = {};
+      const replimit = opts.limit === void 0 ? 25 : opts.limit;
+      if (isRegExp(re)) re = re.source;
+      else if (typeof re !== "string") re = String(re);
+      try {
+        re = parse(re);
+      } catch {
+        return false;
+      }
+      let reps = 0;
+      return (function walk(node, starHeight) {
+        let i;
+        let ok2;
+        let len;
+        if (node.type === types.REPETITION) {
+          starHeight++;
+          reps++;
+          if (starHeight > 1) return false;
+          if (reps > replimit) return false;
+        }
+        if (node.options) {
+          for (i = 0, len = node.options.length; i < len; i++) {
+            ok2 = walk({ stack: node.options[i] }, starHeight);
+            if (!ok2) return false;
+          }
+        }
+        const stack = node.stack || node.value?.stack;
+        if (!stack) return true;
+        for (i = 0; i < stack.length; i++) {
+          ok2 = walk(stack[i], starHeight);
+          if (!ok2) return false;
+        }
+        return true;
+      })(re, 0);
+    }
+    function isRegExp(x) {
+      return {}.toString.call(x) === "[object RegExp]";
+    }
+    module.exports = safeRegex2;
+    module.exports.default = safeRegex2;
+    module.exports.safeRegex = safeRegex2;
+  }
+});
+
+// lib/custom-schemas.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+
+// ../../packages/cms-schema/src/documents/registry.ts
+import { z } from "zod";
+var schemaNameValidator = z.string().min(1, "Schema name must be a non-empty string").refine((name) => name.trim().length > 0, "Schema name must not be only whitespace");
+var documentSchemaConfigValidator = z.object({
+  schema: z.custom(
+    (val) => val !== null && typeof val === "object" && "_def" in val,
+    { message: "schema must be a valid Zod schema" }
+  ),
+  titleField: z.string().optional(),
+  displayName: z.string().optional(),
+  description: z.string().optional(),
+  validateContent: z.function().optional()
+});
+
+// ../../packages/cms-schema/src/documents/schemas/country.ts
+import { z as z2 } from "zod";
+var LanguageReferenceSchema = z2.object({
+  _type: z2.literal("reference"),
+  _ref: z2.string().uuid("Language reference must be a valid UUID"),
+  _schema: z2.literal("language")
+});
+var CountrySchema = z2.object({
+  /** 2-letter ISO 3166-1 alpha-2 country code */
+  code: z2.string().length(2, "Country code must be 2 characters"),
+  /** English name of the country */
+  name: z2.string().min(1, "Country name required"),
+  /** Flag emoji (optional but recommended) */
+  flag: z2.string().optional(),
+  /**
+   * List of supported languages (at least one required).
+   * Supports either:
+   * - Language codes (new format)
+   * - Document references to languages (legacy format for backward compatibility)
+   */
+  languages: z2.array(
+    z2.union([z2.string().length(2, "Language code must be 2 characters"), LanguageReferenceSchema])
+  ).min(1, "At least one language required")
+});
+
+// ../../packages/cms-schema/src/documents/schemas/language.ts
+import { z as z3 } from "zod";
+var LanguageSchema = z3.object({
+  /** 2-letter ISO 639-1 language code */
+  code: z3.string().length(2, "Language code must be 2 characters"),
+  /** English name of the language */
+  name: z3.string().min(1, "Language name required"),
+  /** Name in the language itself (optional but recommended) */
+  nativeName: z3.string().optional()
+});
+
+// ../../packages/cms-schema/src/documents/unified-registry.ts
+import { z as z7 } from "zod";
+
+// ../../packages/cms-schema/src/documents/rehydration.ts
+import { z as z6 } from "zod";
+
+// ../../packages/cms-schema/src/fields/complex/media.ts
+import { z as z5 } from "zod";
+
+// ../../packages/cms-schema/src/validation/image.ts
+import { z as z4 } from "zod";
+var ALLOWED_MIME_TYPES = ["image/jpeg", "image/png", "image/webp"];
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+var MIN_FILE_SIZE = 1024;
+var MAX_DIMENSION = 8192;
+var MIN_DIMENSION = 10;
+var MimeTypeSchema = z4.enum(ALLOWED_MIME_TYPES);
+var FileSizeSchema = z4.number().int().min(MIN_FILE_SIZE, `File too small. Minimum: ${MIN_FILE_SIZE} bytes`).max(MAX_FILE_SIZE, `File too large. Maximum: ${MAX_FILE_SIZE / 1024 / 1024}MB`);
+var DimensionSchema = z4.number().int().min(MIN_DIMENSION, `Dimension too small. Minimum: ${MIN_DIMENSION}px`).max(MAX_DIMENSION, `Dimension too large. Maximum: ${MAX_DIMENSION}px`);
+var UploadRequestSchema = z4.object({
+  filename: z4.string().min(1, "Filename is required").max(255, "Filename too long").regex(/^[^<>:"/\\|?*]+$/, "Filename contains invalid characters"),
+  mimeType: MimeTypeSchema,
+  fileSize: FileSizeSchema
+});
+var ConfirmUploadSchema = z4.object({
+  assetId: z4.uuid().optional(),
+  width: DimensionSchema,
+  height: DimensionSchema
+});
+
+// ../../packages/cms-schema/src/fields/complex/media.ts
+var ImageAssetSchema = z5.object({
+  /** UUID primary key */
+  id: z5.uuid(),
+  /** R2/S3 storage URL for the original file */
+  url: z5.url(),
+  /** Image width in pixels */
+  width: DimensionSchema,
+  /** Image height in pixels */
+  height: DimensionSchema,
+  /** Original filename from upload */
+  originalFilename: z5.string().min(1).max(255),
+  /** MIME type (only web-safe formats allowed) */
+  mimeType: MimeTypeSchema,
+  /** File size in bytes */
+  fileSize: FileSizeSchema,
+  /** Base64-encoded tiny preview for blur-up loading */
+  lqip: z5.string().optional()
+});
+var HotspotSchema = z5.object({
+  x: z5.number().min(0).max(1),
+  y: z5.number().min(0).max(1)
+});
+var CropSchema = z5.object({
+  /** X coordinate of top-left corner in pixels */
+  x: z5.number().int().nonnegative(),
+  /** Y coordinate of top-left corner in pixels */
+  y: z5.number().int().nonnegative(),
+  /** Width of crop region in pixels (must be > 0) */
+  width: z5.number().int().positive(),
+  /** Height of crop region in pixels (must be > 0) */
+  height: z5.number().int().positive()
+});
+var ImageReferenceSchema = z5.object({
+  // Alt text is REQUIRED for accessibility
+  alt: z5.string().min(1, "Alt text is required for accessibility"),
+  // Optional metadata
+  caption: z5.string().max(500).optional(),
+  attribution: z5.string().max(255).optional(),
+  // Reference to the ImageAsset with stored transformation
+  _asset: z5.object({
+    id: z5.uuid(),
+    transformation: z5.string().nullable().optional()
+  })
+});
+var fileSchema = z5.object({
+  url: z5.url(),
+  name: z5.string(),
+  size: z5.number().int().positive(),
+  type: z5.string()
+});
+
+// ../../packages/cms-schema/src/utils/safe-regex.ts
+var import_safe_regex2 = __toESM(require_safe_regex2(), 1);
+function validateSafeRegex(pattern) {
+  if (pattern.length > 500) {
+    return "Regex pattern is too long (max 500 characters)";
+  }
+  if (!(0, import_safe_regex2.default)(pattern)) {
+    return "Regex pattern is potentially unsafe (ReDoS risk)";
+  }
+  try {
+    new RegExp(pattern);
+  } catch (err2) {
+    return `Invalid regex: ${err2 instanceof Error ? err2.message : "Unknown"}`;
+  }
+  return null;
+}
+
+// ../../packages/cms-schema/src/documents/rehydration.ts
+var RehydrationError = class extends Error {
+  constructor(message, fieldName, fieldType) {
+    super(message);
+    this.fieldName = fieldName;
+    this.fieldType = fieldType;
+    this.name = "RehydrationError";
+  }
+};
+function rehydrateField(field) {
+  try {
+    let schema = createBaseSchema(field.type, field.constraints);
+    if (!field.required) {
+      schema = schema.optional();
+    }
+    return schema;
+  } catch (err2) {
+    throw new RehydrationError(
+      `Failed to rehydrate field "${field.name}": ${err2 instanceof Error ? err2.message : "Unknown error"}`,
+      field.name,
+      field.type
+    );
+  }
+}
+function createBaseSchema(type, constraints) {
+  switch (type) {
+    case "string":
+      return applyStringConstraints(z6.string(), constraints);
+    case "number":
+      return applyNumberConstraints(z6.number(), constraints);
+    case "boolean":
+      return z6.boolean();
+    case "image":
+      return ImageReferenceSchema;
+    case "date":
+      return z6.string().date("Invalid date format. Expected YYYY-MM-DD");
+    case "datetime":
+      return z6.string().datetime({ offset: true, message: "Invalid datetime format. Expected ISO 8601" });
+    case "url":
+      return applyStringConstraints(z6.string().url("Invalid URL format"), constraints);
+    case "email":
+      return applyStringConstraints(z6.string().email("Invalid email format"), constraints);
+    case "enum": {
+      const values = constraints?.enumValues;
+      if (!values || values.length === 0) {
+        throw new Error("Enum field requires at least one enumValues in constraints");
+      }
+      return z6.enum(values);
+    }
+    case "reference":
+      return z6.record(z6.string(), z6.unknown());
+    case "array": {
+      const itemType = constraints?.arrayItemType ?? "string";
+      const itemSchema = createPrimitiveSchema(itemType);
+      return applyArrayConstraints(z6.array(itemSchema), constraints);
+    }
+    default:
+      throw new Error(`Unknown field type: ${type}`);
+  }
+}
+function createPrimitiveSchema(type) {
+  switch (type) {
+    case "string":
+      return z6.string();
+    case "number":
+      return z6.number();
+    case "boolean":
+      return z6.boolean();
+  }
+}
+function applyStringConstraints(schema, constraints) {
+  if (!constraints) return schema;
+  if (constraints.minLength !== void 0 && constraints.maxLength !== void 0 && constraints.minLength > constraints.maxLength) {
+    throw new Error(
+      `Invalid string constraints: minLength (${constraints.minLength}) cannot be greater than maxLength (${constraints.maxLength})`
+    );
+  }
+  let result = schema;
+  if (constraints.minLength !== void 0) {
+    result = result.min(
+      constraints.minLength,
+      `Must be at least ${constraints.minLength} characters`
+    );
+  }
+  if (constraints.maxLength !== void 0) {
+    result = result.max(
+      constraints.maxLength,
+      `Must be at most ${constraints.maxLength} characters`
+    );
+  }
+  if (constraints.pattern) {
+    const safetyError = validateSafeRegex(constraints.pattern);
+    if (safetyError) {
+      throw new Error(safetyError);
+    }
+    try {
+      result = result.regex(new RegExp(constraints.pattern), "Invalid format");
+    } catch {
+      throw new Error(`Invalid regex pattern: ${constraints.pattern}`);
+    }
+  }
+  return result;
+}
+function applyNumberConstraints(schema, constraints) {
+  if (!constraints) return schema;
+  if (constraints.min !== void 0 && constraints.max !== void 0 && constraints.min > constraints.max) {
+    throw new Error(
+      `Invalid number constraints: min (${constraints.min}) cannot be greater than max (${constraints.max})`
+    );
+  }
+  let result = schema;
+  if (constraints.min !== void 0) {
+    result = result.min(constraints.min, `Must be at least ${constraints.min}`);
+  }
+  if (constraints.max !== void 0) {
+    result = result.max(constraints.max, `Must be at most ${constraints.max}`);
+  }
+  if (constraints.integer) {
+    result = result.int("Must be an integer");
+  }
+  return result;
+}
+function applyArrayConstraints(schema, constraints) {
+  if (!constraints) return schema;
+  if (constraints.minItems !== void 0 && constraints.maxItems !== void 0 && constraints.minItems > constraints.maxItems) {
+    throw new Error(
+      `Invalid array constraints: minItems (${constraints.minItems}) cannot be greater than maxItems (${constraints.maxItems})`
+    );
+  }
+  let result = schema;
+  if (constraints.minItems !== void 0) {
+    result = result.min(constraints.minItems, `Must have at least ${constraints.minItems} items`);
+  }
+  if (constraints.maxItems !== void 0) {
+    result = result.max(constraints.maxItems, `Must have at most ${constraints.maxItems} items`);
+  }
+  return result;
+}
+function rehydrateSchema(fields) {
+  if (!Array.isArray(fields) || fields.length === 0) {
+    throw new RehydrationError("Schema must have at least one field");
+  }
+  const shape = {};
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    if (seenNames.has(field.name)) {
+      throw new RehydrationError(`Duplicate field name: "${field.name}"`);
+    }
+    seenNames.add(field.name);
+    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(field.name)) {
+      throw new RehydrationError(
+        `Invalid field name "${field.name}": must start with a letter and contain only alphanumeric characters and underscores`,
+        field.name
+      );
+    }
+    shape[field.name] = rehydrateField(field);
+  }
+  return z6.object(shape);
+}
+
+// ../../packages/cms-schema/src/documents/schema-hash.ts
+import hash from "object-hash";
+
+// ../../packages/cms-schema/src/documents/validations/country.ts
+import { TRPCError } from "@trpc/server";
+
+// ../../packages/cms-schema/src/documents/generate-zod-code.ts
+function generateZodSchemaCode(schemaName, fields) {
+  const lines = [];
+  lines.push(`import { z } from 'zod';`);
+  lines.push("");
+  const hasImageField = fields.some((f) => f.type === "image");
+  if (hasImageField) {
+    appendImageReferenceSchema(lines);
+    lines.push("");
+  }
+  appendSchemaBody(lines, schemaName, fields);
+  return lines.join("\n");
+}
+function generateCombinedZodSchemaCode(schemas) {
+  const lines = [];
+  lines.push(`import { z } from 'zod';`);
+  lines.push("");
+  const hasImageField = schemas.some((s) => s.fields.some((f) => f.type === "image"));
+  if (hasImageField) {
+    appendImageReferenceSchema(lines);
+    lines.push("");
+  }
+  for (let i = 0; i < schemas.length; i++) {
+    const schema = schemas[i];
+    if (i > 0) lines.push("");
+    appendSchemaBody(lines, schema.name, schema.fields);
+  }
+  return lines.join("\n");
+}
+function appendSchemaBody(lines, schemaName, fields) {
+  const varName = toCamelCase(schemaName) + "Schema";
+  lines.push(`export const ${varName} = z.object({`);
+  for (const field of fields) {
+    const fieldCode = generateFieldCode(field);
+    if (field.description) {
+      lines.push(`  /** ${field.description} */`);
+    }
+    lines.push(`  ${field.name}: ${fieldCode},`);
+  }
+  lines.push("});");
+  lines.push("");
+  lines.push(`export type ${toPascalCase(schemaName)} = z.infer<typeof ${varName}>;`);
+  lines.push("");
+}
+function appendImageReferenceSchema(lines) {
+  lines.push("const ImageReferenceSchema = z.object({");
+  lines.push("  alt: z.string().min(1, 'Alt text is required for accessibility'),");
+  lines.push("  caption: z.string().max(500).optional(),");
+  lines.push("  attribution: z.string().max(255).optional(),");
+  lines.push("  _asset: z.object({");
+  lines.push("    id: z.string().uuid(),");
+  lines.push("  }),");
+  lines.push("});");
+}
+function generateFieldCode(field) {
+  let code = generateBaseTypeCode(field.type, field.constraints);
+  if (!field.required) {
+    code += ".optional()";
+  }
+  return code;
+}
+function generateBaseTypeCode(type, constraints) {
+  switch (type) {
+    case "string":
+      return applyStringConstraintCode("z.string()", constraints);
+    case "number":
+      return applyNumberConstraintCode("z.number()", constraints);
+    case "boolean":
+      return "z.boolean()";
+    case "image":
+      return "ImageReferenceSchema";
+    case "date":
+      return "z.string().date('Invalid date format. Expected YYYY-MM-DD')";
+    case "datetime":
+      return "z.string().datetime({ offset: true, message: 'Invalid datetime format. Expected ISO 8601' })";
+    case "url":
+      return applyStringConstraintCode("z.string().url('Invalid URL format')", constraints);
+    case "email":
+      return applyStringConstraintCode("z.string().email('Invalid email format')", constraints);
+    case "enum": {
+      const values = constraints?.enumValues;
+      if (!values || values.length === 0) {
+        return "z.enum([''])";
+      }
+      const formatted = values.map((v) => `'${escapeString(v)}'`).join(", ");
+      return `z.enum([${formatted}])`;
+    }
+    case "reference":
+      return "z.record(z.string(), z.unknown())";
+    case "array": {
+      const itemType = constraints?.arrayItemType ?? "string";
+      const itemCode = generatePrimitiveCode(itemType);
+      return applyArrayConstraintCode(`z.array(${itemCode})`, constraints);
+    }
+    default:
+      return "z.unknown()";
+  }
+}
+function generatePrimitiveCode(type) {
+  switch (type) {
+    case "string":
+      return "z.string()";
+    case "number":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+  }
+}
+function applyStringConstraintCode(base, constraints) {
+  if (!constraints) return base;
+  let code = base;
+  if (constraints.minLength !== void 0) {
+    code += `.min(${constraints.minLength}, 'Must be at least ${constraints.minLength} characters')`;
+  }
+  if (constraints.maxLength !== void 0) {
+    code += `.max(${constraints.maxLength}, 'Must be at most ${constraints.maxLength} characters')`;
+  }
+  if (constraints.pattern) {
+    code += `.regex(/${escapeRegex(constraints.pattern)}/, 'Invalid format')`;
+  }
+  return code;
+}
+function applyNumberConstraintCode(base, constraints) {
+  if (!constraints) return base;
+  let code = base;
+  if (constraints.integer) {
+    code += `.int('Must be an integer')`;
+  }
+  if (constraints.min !== void 0) {
+    code += `.min(${constraints.min}, 'Must be at least ${constraints.min}')`;
+  }
+  if (constraints.max !== void 0) {
+    code += `.max(${constraints.max}, 'Must be at most ${constraints.max}')`;
+  }
+  return code;
+}
+function applyArrayConstraintCode(base, constraints) {
+  if (!constraints) return base;
+  let code = base;
+  if (constraints.minItems !== void 0) {
+    code += `.min(${constraints.minItems}, 'Must have at least ${constraints.minItems} items')`;
+  }
+  if (constraints.maxItems !== void 0) {
+    code += `.max(${constraints.maxItems}, 'Must have at most ${constraints.maxItems} items')`;
+  }
+  return code;
+}
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function escapeRegex(pattern) {
+  return pattern.replace(/\//g, "\\/");
+}
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toPascalCase(str) {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+// lib/cms-api.ts
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+import superjson from "superjson";
+function getCmsApiUrl(cmsUrl) {
+  return new URL("/api/trpc", cmsUrl).toString();
+}
+function createFetchWithApiKey(apiKey, websiteId) {
+  return async (url, options) => {
+    let finalUrl = url;
+    const urlObj = new URL(url.toString());
+    if (apiKey) {
+      urlObj.searchParams.set("api_key", apiKey);
+    }
+    if (websiteId) {
+      urlObj.searchParams.set("website_id", websiteId);
+    }
+    if (apiKey || websiteId) {
+      finalUrl = urlObj.toString();
+    }
+    const response = await fetch(finalUrl, options);
+    return response;
+  };
+}
+function createCmsClient(options) {
+  const url = getCmsApiUrl(options.cmsUrl);
+  return createTRPCClient({
+    links: [
+      httpBatchLink({
+        url,
+        transformer: superjson,
+        fetch: createFetchWithApiKey(options.apiKey, options.websiteId)
+      })
+    ]
+  });
+}
+function getCmsClient(options) {
+  return createCmsClient(options);
+}
+
+// lib/custom-schemas.ts
+async function fetchAllCustomSchemaFields(options) {
+  const { websiteId } = options;
+  const client = getCmsClient(options);
+  const summaries = await client.customSchema.list.query({
+    websiteId,
+    includeSystem: false
+  });
+  const schemas = await Promise.all(
+    summaries.map(async (summary) => {
+      const detail = await client.customSchema.getByName.query({
+        websiteId,
+        name: summary.name
+      });
+      return {
+        name: detail.name,
+        displayName: detail.displayName,
+        description: detail.description ?? null,
+        fields: detail.fields,
+        routeSlugField: detail.routeSlugField ?? null,
+        version: detail.version
+      };
+    })
+  );
+  return schemas;
+}
+async function fetchCustomSchemaFields(options, schemaName) {
+  const { websiteId } = options;
+  const client = getCmsClient(options);
+  const detail = await client.customSchema.getByName.query({
+    websiteId,
+    name: schemaName
+  });
+  return {
+    name: detail.name,
+    displayName: detail.displayName,
+    description: detail.description ?? null,
+    fields: detail.fields,
+    routeSlugField: detail.routeSlugField ?? null,
+    version: detail.version
+  };
+}
+function buildZodSchemas(schemas) {
+  const result = {};
+  for (const schema of schemas) {
+    result[schema.name] = rehydrateSchema(schema.fields);
+  }
+  return result;
+}
+function buildZodSchemaCode(schemas) {
+  const result = {};
+  for (const schema of schemas) {
+    result[schema.name] = generateZodSchemaCode(schema.name, schema.fields);
+  }
+  return result;
+}
+async function saveZodSchemaCode(schemas, filePath) {
+  if (schemas.length === 0) {
+    console.warn("[saveZodSchemaCode] No schemas provided \u2014 skipping file write.");
+    return;
+  }
+  const code = generateCombinedZodSchemaCode(schemas);
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, code, "utf-8");
+}
+export {
+  buildZodSchemaCode,
+  buildZodSchemas,
+  fetchAllCustomSchemaFields,
+  fetchCustomSchemaFields,
+  saveZodSchemaCode
+};
+//# sourceMappingURL=custom-schemas.js.map