@shipfox/expression 1.1.0

package/dist/template/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/template/errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gCAAgC,8BAA8B,CAAC;AAE5E,qBAAa,4BAA6B,SAAQ,KAAK;IACrD,QAAQ,CAAC,IAAI,+BAAoC;IACjD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAC;CAOtF"}

package/dist/template/errors.js

@@ -0,0 +1,14 @@
+export const invalidWorkflowTemplateErrorCode = 'invalid-workflow-template';
+export class InvalidWorkflowTemplateError extends Error {
+    constructor(params){
+        super('Invalid workflow template', {
+            cause: params.cause
+        }), this.code = invalidWorkflowTemplateErrorCode;
+        this.name = 'InvalidWorkflowTemplateError';
+        this.source = params.source;
+        this.reason = params.reason;
+        this.offset = params.offset;
+    }
+}
+
+//# sourceMappingURL=errors.js.map

package/dist/template/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/template/errors.ts"],"sourcesContent":["export const invalidWorkflowTemplateErrorCode = 'invalid-workflow-template';\n\nexport class InvalidWorkflowTemplateError extends Error {\n  readonly code = invalidWorkflowTemplateErrorCode;\n  readonly source: string;\n  readonly reason: string;\n  readonly offset: number;\n\n  constructor(params: {source: string; reason: string; offset: number; cause?: unknown}) {\n    super('Invalid workflow template', {cause: params.cause});\n    this.name = 'InvalidWorkflowTemplateError';\n    this.source = params.source;\n    this.reason = params.reason;\n    this.offset = params.offset;\n  }\n}\n"],"names":["invalidWorkflowTemplateErrorCode","InvalidWorkflowTemplateError","Error","params","cause","code","name","source","reason","offset"],"mappings":"AAAA,OAAO,MAAMA,mCAAmC,4BAA4B;AAE5E,OAAO,MAAMC,qCAAqCC;IAMhD,YAAYC,MAAyE,CAAE;QACrF,KAAK,CAAC,6BAA6B;YAACC,OAAOD,OAAOC,KAAK;QAAA,SANhDC,OAAOL;QAOd,IAAI,CAACM,IAAI,GAAG;QACZ,IAAI,CAACC,MAAM,GAAGJ,OAAOI,MAAM;QAC3B,IAAI,CAACC,MAAM,GAAGL,OAAOK,MAAM;QAC3B,IAAI,CAACC,MAAM,GAAGN,OAAOM,MAAM;IAC7B;AACF"}

package/dist/template/extract-cel-context-roots.d.ts

@@ -0,0 +1,2 @@
+export declare function extractCelContextRoots(source: string): string[];
+//# sourceMappingURL=extract-cel-context-roots.d.ts.map

package/dist/template/extract-cel-context-roots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-cel-context-roots.d.ts","sourceRoot":"","sources":["../../src/template/extract-cel-context-roots.ts"],"names":[],"mappings":"AAmBA,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAI/D"}

package/dist/template/extract-cel-context-roots.js

@@ -0,0 +1,110 @@
+import { parse as parseCel } from '@marcbachmann/cel-js';
+const binaryOperators = new Set([
+    '!=',
+    '==',
+    'in',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '<',
+    '<=',
+    '>',
+    '>='
+]);
+const comprehensionMethods = new Set([
+    'all',
+    'exists',
+    'exists_one',
+    'filter',
+    'map'
+]);
+export function extractCelContextRoots(source) {
+    const contextRoots = new Set();
+    collectContextRoots(parseCel(source).ast, contextRoots, new Set());
+    return [
+        ...contextRoots
+    ].sort();
+}
+function collectContextRoots(node, contextRoots, scopedIdentifiers) {
+    if (binaryOperators.has(node.op) || node.op === '||' || node.op === '&&') {
+        collectBinaryContextRoots(node.args, contextRoots, scopedIdentifiers);
+        return;
+    }
+    switch(node.op){
+        case 'id':
+            if (!scopedIdentifiers.has(node.args)) contextRoots.add(node.args);
+            return;
+        case 'value':
+            return;
+        case '.':
+        case '.?':
+            collectContextRoots(node.args[0], contextRoots, scopedIdentifiers);
+            return;
+        case '[]':
+        case '[?]':
+            collectBinaryContextRoots(node.args, contextRoots, scopedIdentifiers);
+            return;
+        case 'call':
+            for (const argument of node.args[1]){
+                collectContextRoots(argument, contextRoots, scopedIdentifiers);
+            }
+            return;
+        case 'rcall':
+            {
+                const [method, receiver, args] = node.args;
+                collectContextRoots(receiver, contextRoots, scopedIdentifiers);
+                const binding = bindComprehensionAlias(method, args, scopedIdentifiers);
+                for (const argument of args.slice(binding.skipArgs)){
+                    collectContextRoots(argument, contextRoots, binding.scopedIdentifiers);
+                }
+                return;
+            }
+        case 'list':
+            for (const element of node.args){
+                collectContextRoots(element, contextRoots, scopedIdentifiers);
+            }
+            return;
+        case 'map':
+            for (const [key, value] of node.args){
+                if (key.op !== 'id') collectContextRoots(key, contextRoots, scopedIdentifiers);
+                collectContextRoots(value, contextRoots, scopedIdentifiers);
+            }
+            return;
+        case '?:':
+            collectContextRoots(node.args[0], contextRoots, scopedIdentifiers);
+            collectContextRoots(node.args[1], contextRoots, scopedIdentifiers);
+            collectContextRoots(node.args[2], contextRoots, scopedIdentifiers);
+            return;
+        case '!_':
+        case '-_':
+            collectContextRoots(node.args, contextRoots, scopedIdentifiers);
+            return;
+    }
+    throw new Error(`Unsupported CEL AST operator: ${node.op}`);
+}
+function collectBinaryContextRoots([left, right], contextRoots, scopedIdentifiers) {
+    collectContextRoots(left, contextRoots, scopedIdentifiers);
+    collectContextRoots(right, contextRoots, scopedIdentifiers);
+}
+function bindComprehensionAlias(method, args, scopedIdentifiers) {
+    if (!comprehensionMethods.has(method)) return {
+        scopedIdentifiers,
+        skipArgs: 0
+    };
+    const [alias] = args;
+    if (alias?.op !== 'id') return {
+        scopedIdentifiers,
+        skipArgs: 0
+    };
+    return {
+        scopedIdentifiers: new Set([
+            ...scopedIdentifiers,
+            alias.args
+        ]),
+        skipArgs: 1
+    };
+}
+
+//# sourceMappingURL=extract-cel-context-roots.js.map

package/dist/template/extract-cel-context-roots.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/template/extract-cel-context-roots.ts"],"sourcesContent":["import {type ASTNode, type BinaryOperator, parse as parseCel} from '@marcbachmann/cel-js';\n\nconst binaryOperators = new Set<BinaryOperator>([\n  '!=',\n  '==',\n  'in',\n  '+',\n  '-',\n  '*',\n  '/',\n  '%',\n  '<',\n  '<=',\n  '>',\n  '>=',\n]);\n\nconst comprehensionMethods = new Set(['all', 'exists', 'exists_one', 'filter', 'map']);\n\nexport function extractCelContextRoots(source: string): string[] {\n  const contextRoots = new Set<string>();\n  collectContextRoots(parseCel(source).ast, contextRoots, new Set());\n  return [...contextRoots].sort();\n}\n\nfunction collectContextRoots(\n  node: ASTNode,\n  contextRoots: Set<string>,\n  scopedIdentifiers: ReadonlySet<string>,\n): void {\n  if (binaryOperators.has(node.op as BinaryOperator) || node.op === '||' || node.op === '&&') {\n    collectBinaryContextRoots(node.args as [ASTNode, ASTNode], contextRoots, scopedIdentifiers);\n    return;\n  }\n\n  switch (node.op) {\n    case 'id':\n      if (!scopedIdentifiers.has(node.args)) contextRoots.add(node.args);\n      return;\n    case 'value':\n      return;\n    case '.':\n    case '.?':\n      collectContextRoots(node.args[0], contextRoots, scopedIdentifiers);\n      return;\n    case '[]':\n    case '[?]':\n      collectBinaryContextRoots(node.args, contextRoots, scopedIdentifiers);\n      return;\n    case 'call':\n      for (const argument of node.args[1]) {\n        collectContextRoots(argument, contextRoots, scopedIdentifiers);\n      }\n      return;\n    case 'rcall': {\n      const [method, receiver, args] = node.args as [string, ASTNode, ASTNode[]];\n      collectContextRoots(receiver, contextRoots, scopedIdentifiers);\n      const binding = bindComprehensionAlias(method, args, scopedIdentifiers);\n      for (const argument of args.slice(binding.skipArgs)) {\n        collectContextRoots(argument, contextRoots, binding.scopedIdentifiers);\n      }\n      return;\n    }\n    case 'list':\n      for (const element of node.args) {\n        collectContextRoots(element, contextRoots, scopedIdentifiers);\n      }\n      return;\n    case 'map':\n      for (const [key, value] of node.args) {\n        if (key.op !== 'id') collectContextRoots(key, contextRoots, scopedIdentifiers);\n        collectContextRoots(value, contextRoots, scopedIdentifiers);\n      }\n      return;\n    case '?:':\n      collectContextRoots(node.args[0], contextRoots, scopedIdentifiers);\n      collectContextRoots(node.args[1], contextRoots, scopedIdentifiers);\n      collectContextRoots(node.args[2], contextRoots, scopedIdentifiers);\n      return;\n    case '!_':\n    case '-_':\n      collectContextRoots(node.args, contextRoots, scopedIdentifiers);\n      return;\n  }\n\n  throw new Error(`Unsupported CEL AST operator: ${(node as {op: string}).op}`);\n}\n\nfunction collectBinaryContextRoots(\n  [left, right]: [ASTNode, ASTNode],\n  contextRoots: Set<string>,\n  scopedIdentifiers: ReadonlySet<string>,\n): void {\n  collectContextRoots(left, contextRoots, scopedIdentifiers);\n  collectContextRoots(right, contextRoots, scopedIdentifiers);\n}\n\nfunction bindComprehensionAlias(\n  method: string,\n  args: readonly ASTNode[],\n  scopedIdentifiers: ReadonlySet<string>,\n): {readonly scopedIdentifiers: ReadonlySet<string>; readonly skipArgs: number} {\n  if (!comprehensionMethods.has(method)) return {scopedIdentifiers, skipArgs: 0};\n\n  const [alias] = args;\n  if (alias?.op !== 'id') return {scopedIdentifiers, skipArgs: 0};\n\n  return {\n    scopedIdentifiers: new Set([...scopedIdentifiers, alias.args]),\n    skipArgs: 1,\n  };\n}\n"],"names":["parse","parseCel","binaryOperators","Set","comprehensionMethods","extractCelContextRoots","source","contextRoots","collectContextRoots","ast","sort","node","scopedIdentifiers","has","op","collectBinaryContextRoots","args","add","argument","method","receiver","binding","bindComprehensionAlias","slice","skipArgs","element","key","value","Error","left","right","alias"],"mappings":"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"}

package/dist/template/extract-cel-untrusted-path-accesses.d.ts

@@ -0,0 +1,5 @@
+export declare function extractCelUntrustedPathAccesses(params: {
+    source: string;
+    untrustedPathsByRoot: ReadonlyMap<string, readonly string[]>;
+}): string[];
+//# sourceMappingURL=extract-cel-untrusted-path-accesses.d.ts.map

package/dist/template/extract-cel-untrusted-path-accesses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-cel-untrusted-path-accesses.d.ts","sourceRoot":"","sources":["../../src/template/extract-cel-untrusted-path-accesses.ts"],"names":[],"mappings":"AAiBA,wBAAgB,+BAA+B,CAAC,MAAM,EAAE;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;CAC9D,GAAG,MAAM,EAAE,CASX"}

package/dist/template/extract-cel-untrusted-path-accesses.js

@@ -0,0 +1,140 @@
+import { parse as parseCel } from '@marcbachmann/cel-js';
+const binaryOperators = new Set([
+    '!=',
+    '==',
+    'in',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '<',
+    '<=',
+    '>',
+    '>='
+]);
+export function extractCelUntrustedPathAccesses(params) {
+    const roots = new Set();
+    collectUntrustedPathAccesses(parseCel(params.source).ast, params.untrustedPathsByRoot, roots, new Map());
+    return [
+        ...roots
+    ].sort();
+}
+function collectUntrustedPathAccesses(node, untrustedPathsByRoot, roots, aliases) {
+    if (binaryOperators.has(node.op) || node.op === '||' || node.op === '&&') {
+        collectBinaryUntrustedPathAccesses(node.args, untrustedPathsByRoot, roots, aliases);
+        return;
+    }
+    switch(node.op){
+        case 'id':
+        case 'value':
+            return;
+        case '.':
+        case '.?':
+            {
+                const [target, field] = node.args;
+                collectUntrustedPathAccesses(target, untrustedPathsByRoot, roots, aliases);
+                const root = rootName(target, aliases);
+                if (root && untrustedPathsByRoot.get(root)?.includes(field)) roots.add(root);
+                return;
+            }
+        case '[]':
+        case '[?]':
+            {
+                const [target, key] = node.args;
+                collectUntrustedPathAccesses(target, untrustedPathsByRoot, roots, aliases);
+                collectUntrustedPathAccesses(key, untrustedPathsByRoot, roots, aliases);
+                const root = rootName(target, aliases);
+                if (!root || !untrustedPathsByRoot.has(root)) return;
+                const field = literalFieldName(key);
+                if (field !== undefined) {
+                    if (untrustedPathsByRoot.get(root)?.includes(field)) roots.add(root);
+                    return;
+                }
+                if (!isAllowedListIndex(target, root)) roots.add(root);
+                return;
+            }
+        case 'call':
+            for (const argument of node.args[1]){
+                collectUntrustedPathAccesses(argument, untrustedPathsByRoot, roots, aliases);
+            }
+            return;
+        case 'rcall':
+            {
+                const [method, receiver, args] = node.args;
+                collectUntrustedPathAccesses(receiver, untrustedPathsByRoot, roots, aliases);
+                const nextAliases = comprehensionAliases(method, receiver, args, aliases);
+                for (const argument of args){
+                    collectUntrustedPathAccesses(argument, untrustedPathsByRoot, roots, nextAliases);
+                }
+                return;
+            }
+        case 'list':
+            for (const element of node.args){
+                collectUntrustedPathAccesses(element, untrustedPathsByRoot, roots, aliases);
+            }
+            return;
+        case 'map':
+            for (const [key, value] of node.args){
+                collectUntrustedPathAccesses(key, untrustedPathsByRoot, roots, aliases);
+                collectUntrustedPathAccesses(value, untrustedPathsByRoot, roots, aliases);
+            }
+            return;
+        case '?:':
+            collectUntrustedPathAccesses(node.args[0], untrustedPathsByRoot, roots, aliases);
+            collectUntrustedPathAccesses(node.args[1], untrustedPathsByRoot, roots, aliases);
+            collectUntrustedPathAccesses(node.args[2], untrustedPathsByRoot, roots, aliases);
+            return;
+        case '!_':
+        case '-_':
+            collectUntrustedPathAccesses(node.args, untrustedPathsByRoot, roots, aliases);
+            return;
+    }
+    throw new Error(`Unsupported CEL AST operator: ${node.op}`);
+}
+function collectBinaryUntrustedPathAccesses([left, right], untrustedPathsByRoot, roots, aliases) {
+    collectUntrustedPathAccesses(left, untrustedPathsByRoot, roots, aliases);
+    collectUntrustedPathAccesses(right, untrustedPathsByRoot, roots, aliases);
+}
+function rootName(node, aliases) {
+    switch(node.op){
+        case 'id':
+            return aliases.get(node.args) ?? node.args;
+        case '.':
+        case '.?':
+            return rootName(node.args[0], aliases);
+        case '[]':
+        case '[?]':
+            return rootName(node.args[0], aliases);
+        default:
+            return undefined;
+    }
+}
+function literalFieldName(node) {
+    return node.op === 'value' && typeof node.args === 'string' ? node.args : undefined;
+}
+function isAllowedListIndex(target, root) {
+    return root === 'executions' && target.op === 'id';
+}
+function comprehensionAliases(method, receiver, args, aliases) {
+    if (![
+        'all',
+        'exists',
+        'exists_one',
+        'filter',
+        'map'
+    ].includes(method)) return aliases;
+    const [alias] = args;
+    if (alias?.op !== 'id') return aliases;
+    const root = rootName(receiver, aliases);
+    if (root !== 'executions') return aliases;
+    return new Map([
+        ...aliases,
+        [
+            alias.args,
+            root
+        ]
+    ]);
+}
+
+//# sourceMappingURL=extract-cel-untrusted-path-accesses.js.map

package/dist/template/extract-cel-untrusted-path-accesses.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/template/extract-cel-untrusted-path-accesses.ts"],"sourcesContent":["import {type ASTNode, type BinaryOperator, parse as parseCel} from '@marcbachmann/cel-js';\n\nconst binaryOperators = new Set<BinaryOperator>([\n  '!=',\n  '==',\n  'in',\n  '+',\n  '-',\n  '*',\n  '/',\n  '%',\n  '<',\n  '<=',\n  '>',\n  '>=',\n]);\n\nexport function extractCelUntrustedPathAccesses(params: {\n  source: string;\n  untrustedPathsByRoot: ReadonlyMap<string, readonly string[]>;\n}): string[] {\n  const roots = new Set<string>();\n  collectUntrustedPathAccesses(\n    parseCel(params.source).ast,\n    params.untrustedPathsByRoot,\n    roots,\n    new Map(),\n  );\n  return [...roots].sort();\n}\n\nfunction collectUntrustedPathAccesses(\n  node: ASTNode,\n  untrustedPathsByRoot: ReadonlyMap<string, readonly string[]>,\n  roots: Set<string>,\n  aliases: ReadonlyMap<string, string>,\n): void {\n  if (binaryOperators.has(node.op as BinaryOperator) || node.op === '||' || node.op === '&&') {\n    collectBinaryUntrustedPathAccesses(\n      node.args as [ASTNode, ASTNode],\n      untrustedPathsByRoot,\n      roots,\n      aliases,\n    );\n    return;\n  }\n\n  switch (node.op) {\n    case 'id':\n    case 'value':\n      return;\n    case '.':\n    case '.?': {\n      const [target, field] = node.args as [ASTNode, string];\n      collectUntrustedPathAccesses(target, untrustedPathsByRoot, roots, aliases);\n      const root = rootName(target, aliases);\n      if (root && untrustedPathsByRoot.get(root)?.includes(field)) roots.add(root);\n      return;\n    }\n    case '[]':\n    case '[?]': {\n      const [target, key] = node.args as [ASTNode, ASTNode];\n      collectUntrustedPathAccesses(target, untrustedPathsByRoot, roots, aliases);\n      collectUntrustedPathAccesses(key, untrustedPathsByRoot, roots, aliases);\n      const root = rootName(target, aliases);\n      if (!root || !untrustedPathsByRoot.has(root)) return;\n\n      const field = literalFieldName(key);\n      if (field !== undefined) {\n        if (untrustedPathsByRoot.get(root)?.includes(field)) roots.add(root);\n        return;\n      }\n\n      if (!isAllowedListIndex(target, root)) roots.add(root);\n      return;\n    }\n    case 'call':\n      for (const argument of node.args[1]) {\n        collectUntrustedPathAccesses(argument, untrustedPathsByRoot, roots, aliases);\n      }\n      return;\n    case 'rcall': {\n      const [method, receiver, args] = node.args as [string, ASTNode, ASTNode[]];\n      collectUntrustedPathAccesses(receiver, untrustedPathsByRoot, roots, aliases);\n      const nextAliases = comprehensionAliases(method, receiver, args, aliases);\n      for (const argument of args) {\n        collectUntrustedPathAccesses(argument, untrustedPathsByRoot, roots, nextAliases);\n      }\n      return;\n    }\n    case 'list':\n      for (const element of node.args) {\n        collectUntrustedPathAccesses(element, untrustedPathsByRoot, roots, aliases);\n      }\n      return;\n    case 'map':\n      for (const [key, value] of node.args) {\n        collectUntrustedPathAccesses(key, untrustedPathsByRoot, roots, aliases);\n        collectUntrustedPathAccesses(value, untrustedPathsByRoot, roots, aliases);\n      }\n      return;\n    case '?:':\n      collectUntrustedPathAccesses(node.args[0], untrustedPathsByRoot, roots, aliases);\n      collectUntrustedPathAccesses(node.args[1], untrustedPathsByRoot, roots, aliases);\n      collectUntrustedPathAccesses(node.args[2], untrustedPathsByRoot, roots, aliases);\n      return;\n    case '!_':\n    case '-_':\n      collectUntrustedPathAccesses(node.args, untrustedPathsByRoot, roots, aliases);\n      return;\n  }\n\n  throw new Error(`Unsupported CEL AST operator: ${(node as {op: string}).op}`);\n}\n\nfunction collectBinaryUntrustedPathAccesses(\n  [left, right]: [ASTNode, ASTNode],\n  untrustedPathsByRoot: ReadonlyMap<string, readonly string[]>,\n  roots: Set<string>,\n  aliases: ReadonlyMap<string, string>,\n): void {\n  collectUntrustedPathAccesses(left, untrustedPathsByRoot, roots, aliases);\n  collectUntrustedPathAccesses(right, untrustedPathsByRoot, roots, aliases);\n}\n\nfunction rootName(node: ASTNode, aliases: ReadonlyMap<string, string>): string | undefined {\n  switch (node.op) {\n    case 'id':\n      return aliases.get(node.args) ?? node.args;\n    case '.':\n    case '.?':\n      return rootName(node.args[0], aliases);\n    case '[]':\n    case '[?]':\n      return rootName(node.args[0], aliases);\n    default:\n      return undefined;\n  }\n}\n\nfunction literalFieldName(node: ASTNode): string | undefined {\n  return node.op === 'value' && typeof node.args === 'string' ? node.args : undefined;\n}\n\nfunction isAllowedListIndex(target: ASTNode, root: string): boolean {\n  return root === 'executions' && target.op === 'id';\n}\n\nfunction comprehensionAliases(\n  method: string,\n  receiver: ASTNode,\n  args: readonly ASTNode[],\n  aliases: ReadonlyMap<string, string>,\n): ReadonlyMap<string, string> {\n  if (!['all', 'exists', 'exists_one', 'filter', 'map'].includes(method)) return aliases;\n\n  const [alias] = args;\n  if (alias?.op !== 'id') return aliases;\n\n  const root = rootName(receiver, aliases);\n  if (root !== 'executions') return aliases;\n\n  return new Map([...aliases, [alias.args, root]]);\n}\n"],"names":["parse","parseCel","binaryOperators","Set","extractCelUntrustedPathAccesses","params","roots","collectUntrustedPathAccesses","source","ast","untrustedPathsByRoot","Map","sort","node","aliases","has","op","collectBinaryUntrustedPathAccesses","args","target","field","root","rootName","get","includes","add","key","literalFieldName","undefined","isAllowedListIndex","argument","method","receiver","nextAliases","comprehensionAliases","element","value","Error","left","right","alias"],"mappings":"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"}

package/dist/template/parse-workflow-template.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowTemplateSegment } from './template-segment.js';
+export declare function parseWorkflowTemplate(source: string): WorkflowTemplateSegment[];
+//# sourceMappingURL=parse-workflow-template.d.ts.map

package/dist/template/parse-workflow-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-workflow-template.d.ts","sourceRoot":"","sources":["../../src/template/parse-workflow-template.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,uBAAuB,CAAC;AAEnE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,uBAAuB,EAAE,CA+C/E"}

package/dist/template/parse-workflow-template.js

@@ -0,0 +1,111 @@
+import { createWorkflowExpression } from '../expression/create-workflow-expression.js';
+import { InvalidWorkflowExpressionError } from '../expression/errors.js';
+import { InvalidWorkflowTemplateError } from './errors.js';
+import { extractCelContextRoots } from './extract-cel-context-roots.js';
+import { scanLineComment, scanStringLiteral } from './scan-cel-token.js';
+export function parseWorkflowTemplate(source) {
+    const segments = [];
+    let literal = '';
+    let index = 0;
+    while(index < source.length){
+        if (source.startsWith('$${{', index)) {
+            literal += '${{';
+            index += 4;
+            continue;
+        }
+        if (!source.startsWith('${{', index)) {
+            literal += source[index];
+            index += 1;
+            continue;
+        }
+        if (literal.length > 0) {
+            segments.push({
+                kind: 'literal',
+                text: literal
+            });
+            literal = '';
+        }
+        const expressionStartIndex = index;
+        const closeIndex = findExpressionCloseIndex(source, expressionStartIndex);
+        if (closeIndex === null) {
+            throw new InvalidWorkflowTemplateError({
+                source,
+                offset: expressionStartIndex,
+                reason: 'unterminated opener'
+            });
+        }
+        const innerSource = source.slice(expressionStartIndex + 3, closeIndex);
+        const expression = createTemplateExpression(source, expressionStartIndex, innerSource);
+        const contextRoots = extractTemplateContextRoots(source, expressionStartIndex, expression.source);
+        segments.push({
+            kind: 'expr',
+            expression,
+            contextRoots
+        });
+        index = closeIndex + 2;
+    }
+    if (literal.length > 0) segments.push({
+        kind: 'literal',
+        text: literal
+    });
+    return segments;
+}
+function findExpressionCloseIndex(source, openerIndex) {
+    let index = openerIndex + 3;
+    let depth = 0;
+    while(index < source.length){
+        const stringEndIndex = scanStringLiteral(source, index);
+        if (stringEndIndex !== null) {
+            index = stringEndIndex;
+            continue;
+        }
+        const commentEndIndex = scanLineComment(source, index);
+        if (commentEndIndex !== null) {
+            index = commentEndIndex;
+            continue;
+        }
+        if (depth === 0 && source.startsWith('}}', index)) return index;
+        const char = source[index];
+        if (char === '(' || char === '[' || char === '{') {
+            depth += 1;
+        } else if ((char === ')' || char === ']' || char === '}') && depth > 0) {
+            depth -= 1;
+        }
+        index += 1;
+    }
+    return null;
+}
+function extractTemplateContextRoots(source, expressionStartIndex, expressionSource) {
+    try {
+        return extractCelContextRoots(expressionSource);
+    } catch (error) {
+        throw new InvalidWorkflowTemplateError({
+            source,
+            offset: expressionStartIndex,
+            reason: error instanceof Error ? error.message : 'Expression context roots could not be extracted.',
+            cause: error
+        });
+    }
+}
+function createTemplateExpression(source, expressionStartIndex, innerSource) {
+    try {
+        return createWorkflowExpression({
+            source: innerSource,
+            check: {
+                mode: 'syntax'
+            }
+        });
+    } catch (error) {
+        if (error instanceof InvalidWorkflowExpressionError) {
+            throw new InvalidWorkflowTemplateError({
+                source,
+                offset: expressionStartIndex,
+                reason: error.reason,
+                cause: error
+            });
+        }
+        throw error;
+    }
+}
+
+//# sourceMappingURL=parse-workflow-template.js.map

package/dist/template/parse-workflow-template.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/template/parse-workflow-template.ts"],"sourcesContent":["import {createWorkflowExpression} from '../expression/create-workflow-expression.js';\nimport {InvalidWorkflowExpressionError} from '../expression/errors.js';\nimport {InvalidWorkflowTemplateError} from './errors.js';\nimport {extractCelContextRoots} from './extract-cel-context-roots.js';\nimport {scanLineComment, scanStringLiteral} from './scan-cel-token.js';\nimport type {WorkflowTemplateSegment} from './template-segment.js';\n\nexport function parseWorkflowTemplate(source: string): WorkflowTemplateSegment[] {\n  const segments: WorkflowTemplateSegment[] = [];\n  let literal = '';\n  let index = 0;\n\n  while (index < source.length) {\n    if (source.startsWith('$${{', index)) {\n      literal += '${{';\n      index += 4;\n      continue;\n    }\n\n    if (!source.startsWith('${{', index)) {\n      literal += source[index];\n      index += 1;\n      continue;\n    }\n\n    if (literal.length > 0) {\n      segments.push({kind: 'literal', text: literal});\n      literal = '';\n    }\n\n    const expressionStartIndex = index;\n    const closeIndex = findExpressionCloseIndex(source, expressionStartIndex);\n    if (closeIndex === null) {\n      throw new InvalidWorkflowTemplateError({\n        source,\n        offset: expressionStartIndex,\n        reason: 'unterminated opener',\n      });\n    }\n\n    const innerSource = source.slice(expressionStartIndex + 3, closeIndex);\n    const expression = createTemplateExpression(source, expressionStartIndex, innerSource);\n    const contextRoots = extractTemplateContextRoots(\n      source,\n      expressionStartIndex,\n      expression.source,\n    );\n\n    segments.push({kind: 'expr', expression, contextRoots});\n    index = closeIndex + 2;\n  }\n\n  if (literal.length > 0) segments.push({kind: 'literal', text: literal});\n  return segments;\n}\n\nfunction findExpressionCloseIndex(source: string, openerIndex: number): number | null {\n  let index = openerIndex + 3;\n  let depth = 0;\n\n  while (index < source.length) {\n    const stringEndIndex = scanStringLiteral(source, index);\n    if (stringEndIndex !== null) {\n      index = stringEndIndex;\n      continue;\n    }\n\n    const commentEndIndex = scanLineComment(source, index);\n    if (commentEndIndex !== null) {\n      index = commentEndIndex;\n      continue;\n    }\n\n    if (depth === 0 && source.startsWith('}}', index)) return index;\n\n    const char = source[index];\n    if (char === '(' || char === '[' || char === '{') {\n      depth += 1;\n    } else if ((char === ')' || char === ']' || char === '}') && depth > 0) {\n      depth -= 1;\n    }\n\n    index += 1;\n  }\n\n  return null;\n}\n\nfunction extractTemplateContextRoots(\n  source: string,\n  expressionStartIndex: number,\n  expressionSource: string,\n) {\n  try {\n    return extractCelContextRoots(expressionSource);\n  } catch (error) {\n    throw new InvalidWorkflowTemplateError({\n      source,\n      offset: expressionStartIndex,\n      reason:\n        error instanceof Error ? error.message : 'Expression context roots could not be extracted.',\n      cause: error,\n    });\n  }\n}\n\nfunction createTemplateExpression(\n  source: string,\n  expressionStartIndex: number,\n  innerSource: string,\n) {\n  try {\n    return createWorkflowExpression({\n      source: innerSource,\n      check: {mode: 'syntax'},\n    });\n  } catch (error) {\n    if (error instanceof InvalidWorkflowExpressionError) {\n      throw new InvalidWorkflowTemplateError({\n        source,\n        offset: expressionStartIndex,\n        reason: error.reason,\n        cause: error,\n      });\n    }\n\n    throw error;\n  }\n}\n"],"names":["createWorkflowExpression","InvalidWorkflowExpressionError","InvalidWorkflowTemplateError","extractCelContextRoots","scanLineComment","scanStringLiteral","parseWorkflowTemplate","source","segments","literal","index","length","startsWith","push","kind","text","expressionStartIndex","closeIndex","findExpressionCloseIndex","offset","reason","innerSource","slice","expression","createTemplateExpression","contextRoots","extractTemplateContextRoots","openerIndex","depth","stringEndIndex","commentEndIndex","char","expressionSource","error","Error","message","cause","check","mode"],"mappings":"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"}

package/dist/template/scan-cel-token.d.ts

@@ -0,0 +1,3 @@
+export declare function scanStringLiteral(source: string, index: number): number | null;
+export declare function scanLineComment(source: string, index: number): number | null;
+//# sourceMappingURL=scan-cel-token.d.ts.map

package/dist/template/scan-cel-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-cel-token.d.ts","sourceRoot":"","sources":["../../src/template/scan-cel-token.ts"],"names":[],"mappings":"AAQA,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiB9E;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK5E"}

package/dist/template/scan-cel-token.js

@@ -0,0 +1,55 @@
+const stringPrefixPatterns = [
+    {
+        prefix: 'r',
+        raw: true
+    },
+    {
+        prefix: 'R',
+        raw: true
+    },
+    {
+        prefix: 'b',
+        raw: false
+    },
+    {
+        prefix: 'B',
+        raw: false
+    },
+    {
+        prefix: '',
+        raw: false
+    }
+];
+export function scanStringLiteral(source, index) {
+    for (const { prefix, raw } of stringPrefixPatterns){
+        if (!source.startsWith(prefix, index)) continue;
+        const quoteIndex = index + prefix.length;
+        const quote = source[quoteIndex];
+        if (quote !== '"' && quote !== "'") continue;
+        const tripleQuote = quote.repeat(3);
+        if (source.startsWith(tripleQuote, quoteIndex)) {
+            return scanQuotedString(source, quoteIndex + 3, tripleQuote, raw);
+        }
+        return scanQuotedString(source, quoteIndex + 1, quote, raw);
+    }
+    return null;
+}
+export function scanLineComment(source, index) {
+    if (!source.startsWith('//', index)) return null;
+    const newlineIndex = source.indexOf('\n', index + 2);
+    return newlineIndex === -1 ? source.length : newlineIndex;
+}
+function scanQuotedString(source, startIndex, delimiter, raw) {
+    let index = startIndex;
+    while(index < source.length){
+        if (!raw && source[index] === '\\') {
+            index += 2;
+            continue;
+        }
+        if (source.startsWith(delimiter, index)) return index + delimiter.length;
+        index += 1;
+    }
+    return source.length;
+}
+
+//# sourceMappingURL=scan-cel-token.js.map

package/dist/template/scan-cel-token.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/template/scan-cel-token.ts"],"sourcesContent":["const stringPrefixPatterns = [\n  {prefix: 'r', raw: true},\n  {prefix: 'R', raw: true},\n  {prefix: 'b', raw: false},\n  {prefix: 'B', raw: false},\n  {prefix: '', raw: false},\n] as const;\n\nexport function scanStringLiteral(source: string, index: number): number | null {\n  for (const {prefix, raw} of stringPrefixPatterns) {\n    if (!source.startsWith(prefix, index)) continue;\n\n    const quoteIndex = index + prefix.length;\n    const quote = source[quoteIndex];\n    if (quote !== '\"' && quote !== \"'\") continue;\n\n    const tripleQuote = quote.repeat(3);\n    if (source.startsWith(tripleQuote, quoteIndex)) {\n      return scanQuotedString(source, quoteIndex + 3, tripleQuote, raw);\n    }\n\n    return scanQuotedString(source, quoteIndex + 1, quote, raw);\n  }\n\n  return null;\n}\n\nexport function scanLineComment(source: string, index: number): number | null {\n  if (!source.startsWith('//', index)) return null;\n\n  const newlineIndex = source.indexOf('\\n', index + 2);\n  return newlineIndex === -1 ? source.length : newlineIndex;\n}\n\nfunction scanQuotedString(\n  source: string,\n  startIndex: number,\n  delimiter: string,\n  raw: boolean,\n): number {\n  let index = startIndex;\n  while (index < source.length) {\n    if (!raw && source[index] === '\\\\') {\n      index += 2;\n      continue;\n    }\n\n    if (source.startsWith(delimiter, index)) return index + delimiter.length;\n\n    index += 1;\n  }\n\n  return source.length;\n}\n"],"names":["stringPrefixPatterns","prefix","raw","scanStringLiteral","source","index","startsWith","quoteIndex","length","quote","tripleQuote","repeat","scanQuotedString","scanLineComment","newlineIndex","indexOf","startIndex","delimiter"],"mappings":"AAAA,MAAMA,uBAAuB;IAC3B;QAACC,QAAQ;QAAKC,KAAK;IAAI;IACvB;QAACD,QAAQ;QAAKC,KAAK;IAAI;IACvB;QAACD,QAAQ;QAAKC,KAAK;IAAK;IACxB;QAACD,QAAQ;QAAKC,KAAK;IAAK;IACxB;QAACD,QAAQ;QAAIC,KAAK;IAAK;CACxB;AAED,OAAO,SAASC,kBAAkBC,MAAc,EAAEC,KAAa;IAC7D,KAAK,MAAM,EAACJ,MAAM,EAAEC,GAAG,EAAC,IAAIF,qBAAsB;QAChD,IAAI,CAACI,OAAOE,UAAU,CAACL,QAAQI,QAAQ;QAEvC,MAAME,aAAaF,QAAQJ,OAAOO,MAAM;QACxC,MAAMC,QAAQL,MAAM,CAACG,WAAW;QAChC,IAAIE,UAAU,OAAOA,UAAU,KAAK;QAEpC,MAAMC,cAAcD,MAAME,MAAM,CAAC;QACjC,IAAIP,OAAOE,UAAU,CAACI,aAAaH,aAAa;YAC9C,OAAOK,iBAAiBR,QAAQG,aAAa,GAAGG,aAAaR;QAC/D;QAEA,OAAOU,iBAAiBR,QAAQG,aAAa,GAAGE,OAAOP;IACzD;IAEA,OAAO;AACT;AAEA,OAAO,SAASW,gBAAgBT,MAAc,EAAEC,KAAa;IAC3D,IAAI,CAACD,OAAOE,UAAU,CAAC,MAAMD,QAAQ,OAAO;IAE5C,MAAMS,eAAeV,OAAOW,OAAO,CAAC,MAAMV,QAAQ;IAClD,OAAOS,iBAAiB,CAAC,IAAIV,OAAOI,MAAM,GAAGM;AAC/C;AAEA,SAASF,iBACPR,MAAc,EACdY,UAAkB,EAClBC,SAAiB,EACjBf,GAAY;IAEZ,IAAIG,QAAQW;IACZ,MAAOX,QAAQD,OAAOI,MAAM,CAAE;QAC5B,IAAI,CAACN,OAAOE,MAAM,CAACC,MAAM,KAAK,MAAM;YAClCA,SAAS;YACT;QACF;QAEA,IAAID,OAAOE,UAAU,CAACW,WAAWZ,QAAQ,OAAOA,QAAQY,UAAUT,MAAM;QAExEH,SAAS;IACX;IAEA,OAAOD,OAAOI,MAAM;AACtB"}

package/dist/template/template-segment.d.ts

@@ -0,0 +1,12 @@
+import type { WorkflowExpression } from '../expression/workflow-expression.js';
+export interface WorkflowTemplateLiteralSegment {
+    readonly kind: 'literal';
+    readonly text: string;
+}
+export interface WorkflowTemplateExprSegment {
+    readonly kind: 'expr';
+    readonly expression: WorkflowExpression;
+    readonly contextRoots: readonly string[];
+}
+export type WorkflowTemplateSegment = WorkflowTemplateLiteralSegment | WorkflowTemplateExprSegment;
+//# sourceMappingURL=template-segment.d.ts.map

package/dist/template/template-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-segment.d.ts","sourceRoot":"","sources":["../../src/template/template-segment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,sCAAsC,CAAC;AAE7E,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,MAAM,MAAM,uBAAuB,GAAG,8BAA8B,GAAG,2BAA2B,CAAC"}

package/dist/template/template-segment.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=template-segment.js.map

package/dist/template/template-segment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/template/template-segment.ts"],"sourcesContent":["import type {WorkflowExpression} from '../expression/workflow-expression.js';\n\nexport interface WorkflowTemplateLiteralSegment {\n  readonly kind: 'literal';\n  readonly text: string;\n}\n\nexport interface WorkflowTemplateExprSegment {\n  readonly kind: 'expr';\n  readonly expression: WorkflowExpression;\n  readonly contextRoots: readonly string[];\n}\n\nexport type WorkflowTemplateSegment = WorkflowTemplateLiteralSegment | WorkflowTemplateExprSegment;\n"],"names":[],"mappings":"AAaA,WAAmG"}