@pixerate/editor 0.1.0

package/dist/grammar/index.cjs

@@ -0,0 +1,401 @@
+"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);
+
+// src/grammar/index.ts
+var grammar_exports = {};
+__export(grammar_exports, {
+  INSTRUCTION_REGEX: () => INSTRUCTION_REGEX,
+  TEMPLATE_REGEX: () => TEMPLATE_REGEX,
+  VARIABLE_REGEX: () => VARIABLE_REGEX,
+  extractInstructionNames: () => extractInstructionNames,
+  extractTemplateNames: () => extractTemplateNames,
+  extractVariableNames: () => extractVariableNames,
+  getLatestVersion: () => getLatestVersion,
+  instructionRegex: () => instructionRegex,
+  mapRawOffsetToResolved: () => mapRawOffsetToResolved,
+  mapResolvedOffsetToRaw: () => mapResolvedOffsetToRaw,
+  resolveTemplates: () => resolveTemplates,
+  resolveTemplatesWithMapping: () => resolveTemplatesWithMapping,
+  resolveVariables: () => resolveVariables,
+  templateRegex: () => templateRegex,
+  tokenizePrompt: () => tokenizePrompt,
+  variableRegex: () => variableRegex
+});
+module.exports = __toCommonJS(grammar_exports);
+
+// src/grammar/tokens.ts
+var TEMPLATE_REGEX = /{{\s*([^}]+?)\s*}}/g;
+var VARIABLE_REGEX = /(?<!\{)\{([^{}]+)\}(?!\})/g;
+var INSTRUCTION_REGEX = /__(.+?)__/g;
+var templateRegex = TEMPLATE_REGEX;
+var variableRegex = VARIABLE_REGEX;
+var instructionRegex = INSTRUCTION_REGEX;
+
+// src/grammar/tokenizer.ts
+function tokenizePrompt(text) {
+  if (!text) {
+    return [];
+  }
+  const rawMatches = [];
+  const tmplRegex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);
+  let match;
+  while ((match = tmplRegex.exec(text)) !== null) {
+    rawMatches.push({
+      type: "template",
+      raw: match[0],
+      value: match[1].trim(),
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  const varRegex = new RegExp(VARIABLE_REGEX.source, VARIABLE_REGEX.flags);
+  while ((match = varRegex.exec(text)) !== null) {
+    const start = match.index;
+    const end = start + match[0].length;
+    const overlaps = rawMatches.some(
+      (m) => !(end <= m.start || start >= m.end)
+    );
+    if (!overlaps) {
+      rawMatches.push({
+        type: "variable",
+        raw: match[0],
+        value: match[1].trim(),
+        start,
+        end
+      });
+    }
+  }
+  const instRegex = new RegExp(
+    INSTRUCTION_REGEX.source,
+    INSTRUCTION_REGEX.flags
+  );
+  while ((match = instRegex.exec(text)) !== null) {
+    const start = match.index;
+    const end = start + match[0].length;
+    const overlaps = rawMatches.some(
+      (m) => !(end <= m.start || start >= m.end)
+    );
+    if (!overlaps) {
+      rawMatches.push({
+        type: "instruction",
+        raw: match[0],
+        value: match[1].trim(),
+        start,
+        end
+      });
+    }
+  }
+  rawMatches.sort((a, b) => a.start - b.start);
+  const tokens = [];
+  let currentIdx = 0;
+  for (const m of rawMatches) {
+    if (m.start > currentIdx) {
+      const textChunk = text.slice(currentIdx, m.start);
+      tokens.push({
+        type: "text",
+        raw: textChunk,
+        value: textChunk,
+        start: currentIdx,
+        end: m.start
+      });
+    }
+    tokens.push({
+      type: m.type,
+      raw: m.raw,
+      value: m.value,
+      start: m.start,
+      end: m.end
+    });
+    currentIdx = m.end;
+  }
+  if (currentIdx < text.length) {
+    const textChunk = text.slice(currentIdx);
+    tokens.push({
+      type: "text",
+      raw: textChunk,
+      value: textChunk,
+      start: currentIdx,
+      end: text.length
+    });
+  }
+  return tokens;
+}
+
+// src/grammar/resolver.ts
+function getLatestVersion(template) {
+  if (!template.versions || template.versions.length === 0) {
+    if (template.body !== void 0) {
+      return {
+        id: template.id || "default",
+        version: "1.0",
+        body: template.body
+      };
+    }
+    return void 0;
+  }
+  if (template.latestVersion) {
+    const found = template.versions.find(
+      (v) => v.version === template.latestVersion
+    );
+    if (found) return found;
+  }
+  return template.versions[template.versions.length - 1];
+}
+function resolveTemplates(text, templates = [], options) {
+  const templateMap = /* @__PURE__ */ new Map();
+  for (const t of templates) {
+    templateMap.set(t.name, t);
+  }
+  const maxDepth = options?.maxDepth ?? 10;
+  function resolveRecursive(currentText, visited, depth) {
+    if (depth > maxDepth) {
+      return "[Template max depth exceeded]";
+    }
+    let result = currentText;
+    const regex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);
+    let match;
+    while ((match = regex.exec(result)) !== null) {
+      const [fullMatch, rawTemplateName] = match;
+      const templateName = rawTemplateName.trim();
+      if (visited.has(templateName)) {
+        return "[Template loop detected]";
+      }
+      const template = templateMap.get(templateName);
+      if (!template) {
+        continue;
+      }
+      let versionBody;
+      const boundVersionId = options?.bindings?.[templateName];
+      if (boundVersionId && template.versions) {
+        const boundVersion = template.versions.find(
+          (v) => v.id === boundVersionId || v.version === boundVersionId
+        );
+        versionBody = boundVersion?.body;
+      } else {
+        const latest = getLatestVersion(template);
+        versionBody = latest?.body ?? template.body;
+      }
+      if (versionBody === void 0) {
+        continue;
+      }
+      const nextVisited = new Set(visited);
+      nextVisited.add(templateName);
+      const resolvedBody = resolveRecursive(
+        versionBody,
+        nextVisited,
+        depth + 1
+      );
+      if (resolvedBody === "[Template loop detected]" || resolvedBody === "[Template max depth exceeded]") {
+        return resolvedBody;
+      }
+      result = result.replace(fullMatch, resolvedBody);
+      regex.lastIndex = 0;
+    }
+    return result;
+  }
+  return resolveRecursive(text, /* @__PURE__ */ new Set(), 0);
+}
+function resolveVariables(text, values) {
+  if (!text) return "";
+  return text.replace(
+    new RegExp(VARIABLE_REGEX.source, VARIABLE_REGEX.flags),
+    (fullMatch, varName) => {
+      const key = varName.trim();
+      if (Object.prototype.hasOwnProperty.call(values, key)) {
+        return String(values[key]);
+      }
+      return fullMatch;
+    }
+  );
+}
+function extractTemplateNames(text) {
+  if (!text) return [];
+  const set = /* @__PURE__ */ new Set();
+  const regex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    set.add(match[1].trim());
+  }
+  return Array.from(set);
+}
+function extractVariableNames(text) {
+  if (!text) return [];
+  const set = /* @__PURE__ */ new Set();
+  const regex = new RegExp(VARIABLE_REGEX.source, VARIABLE_REGEX.flags);
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    set.add(match[1].trim());
+  }
+  return Array.from(set);
+}
+function extractInstructionNames(text) {
+  if (!text) return [];
+  const set = /* @__PURE__ */ new Set();
+  const regex = new RegExp(INSTRUCTION_REGEX.source, INSTRUCTION_REGEX.flags);
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    set.add(match[1].trim());
+  }
+  return Array.from(set);
+}
+
+// src/grammar/sourcemap.ts
+function resolveTemplatesWithMapping(text, templates = [], templateBindings) {
+  if (!templates || templates.length === 0 || !text.includes("{{")) {
+    return {
+      text,
+      map: [
+        {
+          resolvedStart: 0,
+          resolvedEnd: text.length,
+          source: "raw",
+          rawStart: 0,
+          rawEnd: text.length
+        }
+      ]
+    };
+  }
+  const templateMap = new Map(templates.map((t) => [t.name, t]));
+  const regex = /{{\s*([^}]+?)\s*}}/g;
+  let match;
+  let lastIndex = 0;
+  let resolvedText = "";
+  const map = [];
+  while ((match = regex.exec(text)) !== null) {
+    const [fullMatch, rawTemplateName] = match;
+    const templateName = rawTemplateName.trim();
+    const matchIndex = match.index;
+    if (matchIndex > lastIndex) {
+      const rawSegment = text.substring(lastIndex, matchIndex);
+      map.push({
+        resolvedStart: resolvedText.length,
+        resolvedEnd: resolvedText.length + rawSegment.length,
+        source: "raw",
+        rawStart: lastIndex,
+        rawEnd: matchIndex
+      });
+      resolvedText += rawSegment;
+    }
+    let resolvedBody = fullMatch;
+    let isTemplate = false;
+    if (templateMap.has(templateName)) {
+      const template = templateMap.get(templateName);
+      let versionBody;
+      const boundVersionId = templateBindings?.[templateName];
+      if (boundVersionId && template.versions) {
+        const boundVersion = template.versions.find(
+          (v) => v.id === boundVersionId || v.version === boundVersionId
+        );
+        versionBody = boundVersion?.body;
+      } else {
+        const latestVersion = getLatestVersion(template);
+        versionBody = latestVersion?.body ?? template.body;
+      }
+      if (versionBody !== void 0) {
+        resolvedBody = resolveTemplates(versionBody, templates, {
+          bindings: templateBindings
+        });
+        isTemplate = true;
+      }
+    }
+    if (isTemplate) {
+      map.push({
+        resolvedStart: resolvedText.length,
+        resolvedEnd: resolvedText.length + resolvedBody.length,
+        source: "template",
+        rawStart: matchIndex,
+        rawEnd: matchIndex + fullMatch.length,
+        templateName
+      });
+      resolvedText += resolvedBody;
+    } else {
+      map.push({
+        resolvedStart: resolvedText.length,
+        resolvedEnd: resolvedText.length + fullMatch.length,
+        source: "raw",
+        rawStart: matchIndex,
+        rawEnd: matchIndex + fullMatch.length
+      });
+      resolvedText += fullMatch;
+    }
+    lastIndex = matchIndex + fullMatch.length;
+  }
+  if (lastIndex < text.length) {
+    const rawSegment = text.substring(lastIndex);
+    map.push({
+      resolvedStart: resolvedText.length,
+      resolvedEnd: resolvedText.length + rawSegment.length,
+      source: "raw",
+      rawStart: lastIndex,
+      rawEnd: text.length
+    });
+    resolvedText += rawSegment;
+  }
+  return { text: resolvedText, map };
+}
+function mapResolvedOffsetToRaw(resolvedOffset, map) {
+  for (let i = 0; i < map.length; i++) {
+    const seg = map[i];
+    const isLast = i === map.length - 1;
+    const inRange = isLast ? resolvedOffset >= seg.resolvedStart && resolvedOffset <= seg.resolvedEnd : resolvedOffset >= seg.resolvedStart && resolvedOffset < seg.resolvedEnd;
+    if (inRange) {
+      if (seg.source === "raw") {
+        return seg.rawStart + (resolvedOffset - seg.resolvedStart);
+      } else {
+        return seg.rawStart;
+      }
+    }
+  }
+  return resolvedOffset;
+}
+function mapRawOffsetToResolved(rawOffset, map) {
+  for (let i = 0; i < map.length; i++) {
+    const seg = map[i];
+    const isLast = i === map.length - 1;
+    const inRange = isLast ? rawOffset >= seg.rawStart && rawOffset <= seg.rawEnd : rawOffset >= seg.rawStart && rawOffset < seg.rawEnd;
+    if (inRange) {
+      if (seg.source === "raw") {
+        return seg.resolvedStart + (rawOffset - seg.rawStart);
+      } else {
+        return seg.resolvedStart;
+      }
+    }
+  }
+  return rawOffset;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INSTRUCTION_REGEX,
+  TEMPLATE_REGEX,
+  VARIABLE_REGEX,
+  extractInstructionNames,
+  extractTemplateNames,
+  extractVariableNames,
+  getLatestVersion,
+  instructionRegex,
+  mapRawOffsetToResolved,
+  mapResolvedOffsetToRaw,
+  resolveTemplates,
+  resolveTemplatesWithMapping,
+  resolveVariables,
+  templateRegex,
+  tokenizePrompt,
+  variableRegex
+});
+//# sourceMappingURL=index.cjs.map

package/dist/grammar/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/grammar/index.ts","../../src/grammar/tokens.ts","../../src/grammar/tokenizer.ts","../../src/grammar/resolver.ts","../../src/grammar/sourcemap.ts"],"sourcesContent":["export * from \"./tokens\";\nexport * from \"./tokenizer\";\nexport * from \"./resolver\";\nexport * from \"./sourcemap\";\n","/**\n * Canonical regex patterns for prompt editing tokens.\n */\nexport const TEMPLATE_REGEX = /{{\\s*([^}]+?)\\s*}}/g;\nexport const VARIABLE_REGEX = /(?<!\\{)\\{([^{}]+)\\}(?!\\})/g;\nexport const INSTRUCTION_REGEX = /__(.+?)__/g;\n\n// Backward-compatible camelCase aliases\nexport const templateRegex = TEMPLATE_REGEX;\nexport const variableRegex = VARIABLE_REGEX;\nexport const instructionRegex = INSTRUCTION_REGEX;\n\nexport type TokenType = \"template\" | \"variable\" | \"instruction\" | \"text\";\n\nexport interface Token {\n  type: TokenType;\n  raw: string;\n  value: string;\n  start: number;\n  end: number;\n}\n\nexport interface TemplateVersion {\n  id: string;\n  version: string;\n  body: string;\n  createdAt?: string;\n}\n\nexport interface Template {\n  id?: string;\n  name: string;\n  body?: string;\n  latestVersion?: string;\n  versions?: TemplateVersion[];\n  color?: string;\n}\n\nexport interface ColorGradient {\n  from: string;\n  to: string;\n}\n","import {\n  TEMPLATE_REGEX,\n  VARIABLE_REGEX,\n  INSTRUCTION_REGEX,\n  Token,\n} from \"./tokens\";\n\ninterface RawMatch {\n  type: \"template\" | \"variable\" | \"instruction\";\n  raw: string;\n  value: string;\n  start: number;\n  end: number;\n}\n\n/**\n * Parses any prompt string into an array of typed tokens in linear order.\n * Plain text between tokens is preserved as `{ type: 'text' }`.\n */\nexport function tokenizePrompt(text: string): Token[] {\n  if (!text) {\n    return [];\n  }\n\n  const rawMatches: RawMatch[] = [];\n\n  // Match {{template}}\n  const tmplRegex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);\n  let match: RegExpExecArray | null;\n  while ((match = tmplRegex.exec(text)) !== null) {\n    rawMatches.push({\n      type: \"template\",\n      raw: match[0],\n      value: match[1].trim(),\n      start: match.index,\n      end: match.index + match[0].length,\n    });\n  }\n\n  // Match {variable}\n  const varRegex = new RegExp(VARIABLE_REGEX.source, VARIABLE_REGEX.flags);\n  while ((match = varRegex.exec(text)) !== null) {\n    // Avoid double matching if overlapping with template\n    const start = match.index;\n    const end = start + match[0].length;\n    const overlaps = rawMatches.some(\n      (m) => !(end <= m.start || start >= m.end),\n    );\n    if (!overlaps) {\n      rawMatches.push({\n        type: \"variable\",\n        raw: match[0],\n        value: match[1].trim(),\n        start,\n        end,\n      });\n    }\n  }\n\n  // Match __instruction__\n  const instRegex = new RegExp(\n    INSTRUCTION_REGEX.source,\n    INSTRUCTION_REGEX.flags,\n  );\n  while ((match = instRegex.exec(text)) !== null) {\n    const start = match.index;\n    const end = start + match[0].length;\n    const overlaps = rawMatches.some(\n      (m) => !(end <= m.start || start >= m.end),\n    );\n    if (!overlaps) {\n      rawMatches.push({\n        type: \"instruction\",\n        raw: match[0],\n        value: match[1].trim(),\n        start,\n        end,\n      });\n    }\n  }\n\n  // Sort matches by start index\n  rawMatches.sort((a, b) => a.start - b.start);\n\n  const tokens: Token[] = [];\n  let currentIdx = 0;\n\n  for (const m of rawMatches) {\n    if (m.start > currentIdx) {\n      const textChunk = text.slice(currentIdx, m.start);\n      tokens.push({\n        type: \"text\",\n        raw: textChunk,\n        value: textChunk,\n        start: currentIdx,\n        end: m.start,\n      });\n    }\n    tokens.push({\n      type: m.type,\n      raw: m.raw,\n      value: m.value,\n      start: m.start,\n      end: m.end,\n    });\n    currentIdx = m.end;\n  }\n\n  if (currentIdx < text.length) {\n    const textChunk = text.slice(currentIdx);\n    tokens.push({\n      type: \"text\",\n      raw: textChunk,\n      value: textChunk,\n      start: currentIdx,\n      end: text.length,\n    });\n  }\n\n  return tokens;\n}\n","import {\n  TEMPLATE_REGEX,\n  VARIABLE_REGEX,\n  INSTRUCTION_REGEX,\n  Template,\n  TemplateVersion,\n} from \"./tokens\";\n\n/**\n * Finds the latest version of a template based on `latestVersion` or last version entry.\n */\nexport function getLatestVersion(\n  template: Template,\n): TemplateVersion | undefined {\n  if (!template.versions || template.versions.length === 0) {\n    if (template.body !== undefined) {\n      return {\n        id: template.id || \"default\",\n        version: \"1.0\",\n        body: template.body,\n      };\n    }\n    return undefined;\n  }\n  if (template.latestVersion) {\n    const found = template.versions.find(\n      (v) => v.version === template.latestVersion,\n    );\n    if (found) return found;\n  }\n  return template.versions[template.versions.length - 1];\n}\n\nexport interface ResolveTemplatesOptions {\n  bindings?: Record<string, string>;\n  maxDepth?: number;\n}\n\n/**\n * Recursively resolves template tags `{{template_name}}` in a given text.\n * Detects circular dependencies and returns \"[Template loop detected]\".\n */\nexport function resolveTemplates(\n  text: string,\n  templates: Template[] = [],\n  options?: ResolveTemplatesOptions,\n): string {\n  const templateMap = new Map<string, Template>();\n  for (const t of templates) {\n    templateMap.set(t.name, t);\n  }\n\n  const maxDepth = options?.maxDepth ?? 10;\n\n  function resolveRecursive(\n    currentText: string,\n    visited: Set<string>,\n    depth: number,\n  ): string {\n    if (depth > maxDepth) {\n      return \"[Template max depth exceeded]\";\n    }\n\n    let result = currentText;\n    const regex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);\n    let match: RegExpExecArray | null;\n\n    while ((match = regex.exec(result)) !== null) {\n      const [fullMatch, rawTemplateName] = match;\n      const templateName = rawTemplateName.trim();\n\n      if (visited.has(templateName)) {\n        return \"[Template loop detected]\";\n      }\n\n      const template = templateMap.get(templateName);\n      if (!template) {\n        continue;\n      }\n\n      let versionBody: string | undefined;\n      const boundVersionId = options?.bindings?.[templateName];\n\n      if (boundVersionId && template.versions) {\n        const boundVersion = template.versions.find(\n          (v) => v.id === boundVersionId || v.version === boundVersionId,\n        );\n        versionBody = boundVersion?.body;\n      } else {\n        const latest = getLatestVersion(template);\n        versionBody = latest?.body ?? template.body;\n      }\n\n      if (versionBody === undefined) {\n        continue;\n      }\n\n      const nextVisited = new Set(visited);\n      nextVisited.add(templateName);\n\n      const resolvedBody = resolveRecursive(\n        versionBody,\n        nextVisited,\n        depth + 1,\n      );\n\n      if (\n        resolvedBody === \"[Template loop detected]\" ||\n        resolvedBody === \"[Template max depth exceeded]\"\n      ) {\n        return resolvedBody;\n      }\n\n      result = result.replace(fullMatch, resolvedBody);\n      regex.lastIndex = 0;\n    }\n\n    return result;\n  }\n\n  return resolveRecursive(text, new Set(), 0);\n}\n\n/**\n * Replaces `{variableName}` with values from a dictionary.\n */\nexport function resolveVariables(\n  text: string,\n  values: Record<string, string | number>,\n): string {\n  if (!text) return \"\";\n  return text.replace(\n    new RegExp(VARIABLE_REGEX.source, VARIABLE_REGEX.flags),\n    (fullMatch, varName) => {\n      const key = varName.trim();\n      if (Object.prototype.hasOwnProperty.call(values, key)) {\n        return String(values[key]);\n      }\n      return fullMatch;\n    },\n  );\n}\n\n/**\n * Extracts unique template names referenced in text.\n */\nexport function extractTemplateNames(text: string): string[] {\n  if (!text) return [];\n  const set = new Set<string>();\n  const regex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);\n  let match: RegExpExecArray | null;\n  while ((match = regex.exec(text)) !== null) {\n    set.add(match[1].trim());\n  }\n  return Array.from(set);\n}\n\n/**\n * Extracts unique variable names referenced in text.\n */\nexport function extractVariableNames(text: string): string[] {\n  if (!text) return [];\n  const set = new Set<string>();\n  const regex = new RegExp(VARIABLE_REGEX.source, VARIABLE_REGEX.flags);\n  let match: RegExpExecArray | null;\n  while ((match = regex.exec(text)) !== null) {\n    set.add(match[1].trim());\n  }\n  return Array.from(set);\n}\n\n/**\n * Extracts unique instruction names referenced in text.\n */\nexport function extractInstructionNames(text: string): string[] {\n  if (!text) return [];\n  const set = new Set<string>();\n  const regex = new RegExp(INSTRUCTION_REGEX.source, INSTRUCTION_REGEX.flags);\n  let match: RegExpExecArray | null;\n  while ((match = regex.exec(text)) !== null) {\n    set.add(match[1].trim());\n  }\n  return Array.from(set);\n}\n","import { Template } from \"./tokens\";\nimport { getLatestVersion, resolveTemplates } from \"./resolver\";\n\nexport interface SourceMapSegment {\n  resolvedStart: number;\n  resolvedEnd: number;\n  source: \"raw\" | \"template\";\n  rawStart: number;\n  rawEnd: number;\n  templateName?: string;\n}\n\n/**\n * Resolves templates in text while tracking character offset mapping\n * between the raw input and the fully resolved output.\n */\nexport function resolveTemplatesWithMapping(\n  text: string,\n  templates: Template[] = [],\n  templateBindings?: Record<string, string>,\n): { text: string; map: SourceMapSegment[] } {\n  if (!templates || templates.length === 0 || !text.includes(\"{{\")) {\n    return {\n      text,\n      map: [\n        {\n          resolvedStart: 0,\n          resolvedEnd: text.length,\n          source: \"raw\",\n          rawStart: 0,\n          rawEnd: text.length,\n        },\n      ],\n    };\n  }\n\n  const templateMap = new Map(templates.map((t) => [t.name, t]));\n  const regex = /{{\\s*([^}]+?)\\s*}}/g;\n  let match: RegExpExecArray | null;\n  let lastIndex = 0;\n  let resolvedText = \"\";\n  const map: SourceMapSegment[] = [];\n\n  while ((match = regex.exec(text)) !== null) {\n    const [fullMatch, rawTemplateName] = match;\n    const templateName = rawTemplateName.trim();\n    const matchIndex = match.index;\n\n    // Add raw text preceding this template match\n    if (matchIndex > lastIndex) {\n      const rawSegment = text.substring(lastIndex, matchIndex);\n      map.push({\n        resolvedStart: resolvedText.length,\n        resolvedEnd: resolvedText.length + rawSegment.length,\n        source: \"raw\",\n        rawStart: lastIndex,\n        rawEnd: matchIndex,\n      });\n      resolvedText += rawSegment;\n    }\n\n    let resolvedBody = fullMatch;\n    let isTemplate = false;\n\n    if (templateMap.has(templateName)) {\n      const template = templateMap.get(templateName)!;\n      let versionBody: string | undefined;\n      const boundVersionId = templateBindings?.[templateName];\n\n      if (boundVersionId && template.versions) {\n        const boundVersion = template.versions.find(\n          (v) => v.id === boundVersionId || v.version === boundVersionId,\n        );\n        versionBody = boundVersion?.body;\n      } else {\n        const latestVersion = getLatestVersion(template);\n        versionBody = latestVersion?.body ?? template.body;\n      }\n\n      if (versionBody !== undefined) {\n        resolvedBody = resolveTemplates(versionBody, templates, {\n          bindings: templateBindings,\n        });\n        isTemplate = true;\n      }\n    }\n\n    if (isTemplate) {\n      map.push({\n        resolvedStart: resolvedText.length,\n        resolvedEnd: resolvedText.length + resolvedBody.length,\n        source: \"template\",\n        rawStart: matchIndex,\n        rawEnd: matchIndex + fullMatch.length,\n        templateName,\n      });\n      resolvedText += resolvedBody;\n    } else {\n      map.push({\n        resolvedStart: resolvedText.length,\n        resolvedEnd: resolvedText.length + fullMatch.length,\n        source: \"raw\",\n        rawStart: matchIndex,\n        rawEnd: matchIndex + fullMatch.length,\n      });\n      resolvedText += fullMatch;\n    }\n\n    lastIndex = matchIndex + fullMatch.length;\n  }\n\n  // Add any remaining raw text after the final match\n  if (lastIndex < text.length) {\n    const rawSegment = text.substring(lastIndex);\n    map.push({\n      resolvedStart: resolvedText.length,\n      resolvedEnd: resolvedText.length + rawSegment.length,\n      source: \"raw\",\n      rawStart: lastIndex,\n      rawEnd: text.length,\n    });\n    resolvedText += rawSegment;\n  }\n\n  return { text: resolvedText, map };\n}\n\n/**\n * Maps an offset in resolved text back to the corresponding offset in raw text.\n */\nexport function mapResolvedOffsetToRaw(\n  resolvedOffset: number,\n  map: SourceMapSegment[],\n): number {\n  for (let i = 0; i < map.length; i++) {\n    const seg = map[i];\n    const isLast = i === map.length - 1;\n    const inRange = isLast\n      ? resolvedOffset >= seg.resolvedStart && resolvedOffset <= seg.resolvedEnd\n      : resolvedOffset >= seg.resolvedStart && resolvedOffset < seg.resolvedEnd;\n\n    if (inRange) {\n      if (seg.source === \"raw\") {\n        return seg.rawStart + (resolvedOffset - seg.resolvedStart);\n      } else {\n        // Pointing into a resolved template - return start of template tag\n        return seg.rawStart;\n      }\n    }\n  }\n  return resolvedOffset;\n}\n\n/**\n * Maps an offset in raw text to the corresponding offset in resolved text.\n */\nexport function mapRawOffsetToResolved(\n  rawOffset: number,\n  map: SourceMapSegment[],\n): number {\n  for (let i = 0; i < map.length; i++) {\n    const seg = map[i];\n    const isLast = i === map.length - 1;\n    const inRange = isLast\n      ? rawOffset >= seg.rawStart && rawOffset <= seg.rawEnd\n      : rawOffset >= seg.rawStart && rawOffset < seg.rawEnd;\n\n    if (inRange) {\n      if (seg.source === \"raw\") {\n        return seg.resolvedStart + (rawOffset - seg.rawStart);\n      } else {\n        return seg.resolvedStart;\n      }\n    }\n  }\n  return rawOffset;\n}\n"],"mappings":"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","names":[]}

package/dist/grammar/index.d.cts

@@ -0,0 +1,65 @@
+import { T as Token, b as Template, c as TemplateVersion } from '../tokens-CE6SS_hd.cjs';
+export { C as ColorGradient, I as INSTRUCTION_REGEX, a as TEMPLATE_REGEX, d as TokenType, V as VARIABLE_REGEX, i as instructionRegex, t as templateRegex, v as variableRegex } from '../tokens-CE6SS_hd.cjs';
+
+/**
+ * Parses any prompt string into an array of typed tokens in linear order.
+ * Plain text between tokens is preserved as `{ type: 'text' }`.
+ */
+declare function tokenizePrompt(text: string): Token[];
+
+/**
+ * Finds the latest version of a template based on `latestVersion` or last version entry.
+ */
+declare function getLatestVersion(template: Template): TemplateVersion | undefined;
+interface ResolveTemplatesOptions {
+    bindings?: Record<string, string>;
+    maxDepth?: number;
+}
+/**
+ * Recursively resolves template tags `{{template_name}}` in a given text.
+ * Detects circular dependencies and returns "[Template loop detected]".
+ */
+declare function resolveTemplates(text: string, templates?: Template[], options?: ResolveTemplatesOptions): string;
+/**
+ * Replaces `{variableName}` with values from a dictionary.
+ */
+declare function resolveVariables(text: string, values: Record<string, string | number>): string;
+/**
+ * Extracts unique template names referenced in text.
+ */
+declare function extractTemplateNames(text: string): string[];
+/**
+ * Extracts unique variable names referenced in text.
+ */
+declare function extractVariableNames(text: string): string[];
+/**
+ * Extracts unique instruction names referenced in text.
+ */
+declare function extractInstructionNames(text: string): string[];
+
+interface SourceMapSegment {
+    resolvedStart: number;
+    resolvedEnd: number;
+    source: "raw" | "template";
+    rawStart: number;
+    rawEnd: number;
+    templateName?: string;
+}
+/**
+ * Resolves templates in text while tracking character offset mapping
+ * between the raw input and the fully resolved output.
+ */
+declare function resolveTemplatesWithMapping(text: string, templates?: Template[], templateBindings?: Record<string, string>): {
+    text: string;
+    map: SourceMapSegment[];
+};
+/**
+ * Maps an offset in resolved text back to the corresponding offset in raw text.
+ */
+declare function mapResolvedOffsetToRaw(resolvedOffset: number, map: SourceMapSegment[]): number;
+/**
+ * Maps an offset in raw text to the corresponding offset in resolved text.
+ */
+declare function mapRawOffsetToResolved(rawOffset: number, map: SourceMapSegment[]): number;
+
+export { type ResolveTemplatesOptions, type SourceMapSegment, Template, TemplateVersion, Token, extractInstructionNames, extractTemplateNames, extractVariableNames, getLatestVersion, mapRawOffsetToResolved, mapResolvedOffsetToRaw, resolveTemplates, resolveTemplatesWithMapping, resolveVariables, tokenizePrompt };

package/dist/grammar/index.d.ts

@@ -0,0 +1,65 @@
+import { T as Token, b as Template, c as TemplateVersion } from '../tokens-CE6SS_hd.js';
+export { C as ColorGradient, I as INSTRUCTION_REGEX, a as TEMPLATE_REGEX, d as TokenType, V as VARIABLE_REGEX, i as instructionRegex, t as templateRegex, v as variableRegex } from '../tokens-CE6SS_hd.js';
+
+/**
+ * Parses any prompt string into an array of typed tokens in linear order.
+ * Plain text between tokens is preserved as `{ type: 'text' }`.
+ */
+declare function tokenizePrompt(text: string): Token[];
+
+/**
+ * Finds the latest version of a template based on `latestVersion` or last version entry.
+ */
+declare function getLatestVersion(template: Template): TemplateVersion | undefined;
+interface ResolveTemplatesOptions {
+    bindings?: Record<string, string>;
+    maxDepth?: number;
+}
+/**
+ * Recursively resolves template tags `{{template_name}}` in a given text.
+ * Detects circular dependencies and returns "[Template loop detected]".
+ */
+declare function resolveTemplates(text: string, templates?: Template[], options?: ResolveTemplatesOptions): string;
+/**
+ * Replaces `{variableName}` with values from a dictionary.
+ */
+declare function resolveVariables(text: string, values: Record<string, string | number>): string;
+/**
+ * Extracts unique template names referenced in text.
+ */
+declare function extractTemplateNames(text: string): string[];
+/**
+ * Extracts unique variable names referenced in text.
+ */
+declare function extractVariableNames(text: string): string[];
+/**
+ * Extracts unique instruction names referenced in text.
+ */
+declare function extractInstructionNames(text: string): string[];
+
+interface SourceMapSegment {
+    resolvedStart: number;
+    resolvedEnd: number;
+    source: "raw" | "template";
+    rawStart: number;
+    rawEnd: number;
+    templateName?: string;
+}
+/**
+ * Resolves templates in text while tracking character offset mapping
+ * between the raw input and the fully resolved output.
+ */
+declare function resolveTemplatesWithMapping(text: string, templates?: Template[], templateBindings?: Record<string, string>): {
+    text: string;
+    map: SourceMapSegment[];
+};
+/**
+ * Maps an offset in resolved text back to the corresponding offset in raw text.
+ */
+declare function mapResolvedOffsetToRaw(resolvedOffset: number, map: SourceMapSegment[]): number;
+/**
+ * Maps an offset in raw text to the corresponding offset in resolved text.
+ */
+declare function mapRawOffsetToResolved(rawOffset: number, map: SourceMapSegment[]): number;
+
+export { type ResolveTemplatesOptions, type SourceMapSegment, Template, TemplateVersion, Token, extractInstructionNames, extractTemplateNames, extractVariableNames, getLatestVersion, mapRawOffsetToResolved, mapResolvedOffsetToRaw, resolveTemplates, resolveTemplatesWithMapping, resolveVariables, tokenizePrompt };