@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/parser/directive-parser.js

@@ -0,0 +1,249 @@
+import { findMatchingDelimiter } from "./tokenizer.js";
+export function extractParenthesizedExpression(source, startPos) {
+  const result = extractParenthesizedExpressionDetailed(source, startPos);
+  return result.ok ? { expression: result.expression, endPos: result.endPos } : null;
+}
+export function extractParenthesizedExpressionDetailed(source, startPos) {
+  let pos = startPos;
+  while (pos < source.length && /\s/.test(source[pos]))
+    pos++;
+  if (source[pos] !== "(")
+    return { ok: !1, reason: "missing-open-paren", pos };
+  const closePos = findMatchingDelimiter(source, "(", ")", pos);
+  if (closePos === -1)
+    return { ok: !1, reason: "unclosed-paren", pos };
+  return { ok: !0, expression: source.slice(pos + 1, closePos), endPos: closePos + 1 };
+}
+export function isInsideTag(source, pos) {
+  const lastOpen = source.lastIndexOf("<", pos);
+  if (lastOpen === -1)
+    return !1;
+  return lastOpen > source.lastIndexOf(">", pos);
+}
+export function findMatchingEndTag(source, startName, endName, startPos) {
+  let depth = 1, pos = startPos;
+  const openPattern = new RegExp(`@${startName}\\s*\\(`, "g"), closePattern = new RegExp(`@${endName}(?![a-z])`, "g");
+  while (pos < source.length && depth > 0) {
+    openPattern.lastIndex = pos;
+    closePattern.lastIndex = pos;
+    const openMatch = openPattern.exec(source), closeMatch = closePattern.exec(source), nextOpen = openMatch ? openMatch.index : 1 / 0, nextClose = closeMatch ? closeMatch.index : 1 / 0;
+    if (nextOpen < nextClose) {
+      depth++;
+      pos = nextOpen + openMatch[0].length;
+    } else if (nextClose < 1 / 0) {
+      depth--;
+      if (depth === 0)
+        return nextClose;
+      pos = nextClose + closeMatch[0].length;
+    } else
+      break;
+  }
+  return -1;
+}
+export function parseConditionalBlock(source, startPos) {
+  const ifMatch = source.slice(startPos).match(/^@if\s*/);
+  if (!ifMatch)
+    return null;
+  const exprStart = startPos + ifMatch[0].length, exprResult = extractParenthesizedExpression(source, exprStart);
+  if (!exprResult)
+    return null;
+  const contentStart = exprResult.endPos, endIfPos = findMatchingEndTag(source, "if", "endif", contentStart);
+  if (endIfPos === -1)
+    return null;
+  const fullContent = source.slice(contentStart, endIfPos), branches = [];
+  let currentPos = 0, currentType = "if", currentCondition = exprResult.expression, branchStart = 0, nestedDepth = 0;
+  while (currentPos < fullContent.length) {
+    const atIdx = fullContent.indexOf("@", currentPos);
+    if (atIdx === -1)
+      break;
+    currentPos = atIdx;
+    const remaining = fullContent.substring(atIdx);
+    if (isInsideTag(fullContent, atIdx)) {
+      currentPos++;
+      continue;
+    }
+    if (/^@if\s*\(/.test(remaining)) {
+      nestedDepth++;
+      currentPos++;
+      continue;
+    }
+    if (/^@endif(?![a-z])/.test(remaining)) {
+      nestedDepth--;
+      currentPos += 6;
+      continue;
+    }
+    if (nestedDepth === 0) {
+      const elseifMatch = remaining.match(/^@elseif\s*/);
+      if (elseifMatch) {
+        branches.push({
+          type: currentType,
+          condition: currentCondition,
+          content: fullContent.substring(branchStart, currentPos),
+          start: contentStart + branchStart,
+          end: contentStart + currentPos
+        });
+        const elseifExprStart = currentPos + elseifMatch[0].length, elseifExpr = extractParenthesizedExpression(fullContent, elseifExprStart);
+        if (!elseifExpr) {
+          currentPos++;
+          continue;
+        }
+        currentType = "elseif";
+        currentCondition = elseifExpr.expression;
+        currentPos = elseifExpr.endPos;
+        branchStart = currentPos;
+        continue;
+      } else if (/^@else(?![a-z])/.test(remaining)) {
+        branches.push({
+          type: currentType,
+          condition: currentCondition,
+          content: fullContent.substring(branchStart, currentPos),
+          start: contentStart + branchStart,
+          end: contentStart + currentPos
+        });
+        currentType = "else";
+        currentCondition = void 0;
+        currentPos += 5;
+        branchStart = currentPos;
+        continue;
+      }
+    }
+    currentPos++;
+  }
+  branches.push({
+    type: currentType,
+    condition: currentCondition,
+    content: fullContent.slice(branchStart),
+    start: contentStart + branchStart,
+    end: contentStart + fullContent.length
+  });
+  return {
+    fullMatch: source.slice(startPos, endIfPos + 6),
+    branches,
+    start: startPos,
+    end: endIfPos + 6
+  };
+}
+export function findIfBlocks(source) {
+  const results = [], ifPattern = /@if\s*\(/g;
+  let match = ifPattern.exec(source);
+  while (match !== null) {
+    if (results.some((r) => match.index > r.start && match.index < r.end)) {
+      match = ifPattern.exec(source);
+      continue;
+    }
+    const parsed = parseConditionalBlock(source, match.index);
+    if (parsed) {
+      results.push(parsed);
+      ifPattern.lastIndex = parsed.end;
+    }
+    match = ifPattern.exec(source);
+  }
+  return results;
+}
+export function findDirectiveBlocks(source, directiveName, endDirectiveName) {
+  const results = [], pattern = new RegExp(`@${directiveName}\\s*\\(`, "g");
+  let match = pattern.exec(source);
+  while (match !== null) {
+    if (results.some((r) => match.index > r.start && match.index < r.end)) {
+      match = pattern.exec(source);
+      continue;
+    }
+    const startPos = match.index, exprStart = startPos + match[0].length - 1, closeParenPos = findMatchingDelimiter(source, "(", ")", exprStart);
+    if (closeParenPos === -1) {
+      match = pattern.exec(source);
+      continue;
+    }
+    const params = source.slice(exprStart + 1, closeParenPos), contentStart = closeParenPos + 1, endPos = findMatchingEndTag(source, directiveName, endDirectiveName, contentStart);
+    if (endPos === -1) {
+      match = pattern.exec(source);
+      continue;
+    }
+    const content = source.slice(contentStart, endPos), fullEnd = endPos + `@${endDirectiveName}`.length;
+    results.push({
+      fullMatch: source.slice(startPos, fullEnd),
+      name: directiveName,
+      params,
+      content,
+      start: startPos,
+      end: fullEnd
+    });
+    pattern.lastIndex = fullEnd;
+    match = pattern.exec(source);
+  }
+  return results;
+}
+export function parseSwitchBlock(source, startPos) {
+  const switchMatch = source.slice(startPos).match(/^@switch\s*/);
+  if (!switchMatch)
+    return null;
+  const exprStart = startPos + switchMatch[0].length, exprResult = extractParenthesizedExpression(source, exprStart);
+  if (!exprResult)
+    return null;
+  const contentStart = exprResult.endPos, endPos = findMatchingEndTag(source, "switch", "endswitch", contentStart);
+  if (endPos === -1)
+    return null;
+  const content = source.slice(contentStart, endPos), cases = [];
+  let currentPos = 0, currentCase = null, nestedSwitchDepth = 0;
+  while (currentPos < content.length) {
+    const remaining = content.slice(currentPos), nestedSwitchMatch = remaining.match(/^@switch\s*\(/), nestedEndSwitchMatch = remaining.match(/^@endswitch(?![a-z])/);
+    if (nestedSwitchMatch) {
+      nestedSwitchDepth++;
+      if (currentCase)
+        currentCase.content += nestedSwitchMatch[0];
+      currentPos += nestedSwitchMatch[0].length;
+      continue;
+    }
+    if (nestedEndSwitchMatch) {
+      nestedSwitchDepth--;
+      if (currentCase)
+        currentCase.content += nestedEndSwitchMatch[0];
+      currentPos += nestedEndSwitchMatch[0].length;
+      continue;
+    }
+    if (nestedSwitchDepth > 0) {
+      if (currentCase)
+        currentCase.content += content[currentPos];
+      currentPos++;
+      continue;
+    }
+    const caseMatch = remaining.match(/^@case\s*/), defaultMatch = remaining.match(/^@default(?![a-z])/), breakMatch = remaining.match(/^@break(?![a-z])/);
+    if (caseMatch && remaining.startsWith("@case")) {
+      if (currentCase)
+        cases.push(currentCase);
+      const caseExprStart = currentPos + caseMatch[0].length, caseExpr = extractParenthesizedExpression(content, caseExprStart);
+      if (!caseExpr) {
+        currentPos++;
+        continue;
+      }
+      currentCase = {
+        type: "case",
+        value: caseExpr.expression,
+        content: ""
+      };
+      currentPos = caseExpr.endPos;
+    } else if (defaultMatch && remaining.startsWith("@default")) {
+      if (currentCase)
+        cases.push(currentCase);
+      currentCase = {
+        type: "default",
+        content: ""
+      };
+      currentPos += defaultMatch[0].length;
+    } else if (breakMatch && remaining.startsWith("@break"))
+      currentPos += breakMatch[0].length;
+    else {
+      if (currentCase)
+        currentCase.content += content[currentPos];
+      currentPos++;
+    }
+  }
+  if (currentCase)
+    cases.push(currentCase);
+  return {
+    fullMatch: source.slice(startPos, endPos + 10),
+    expression: exprResult.expression,
+    cases,
+    start: startPos,
+    end: endPos + 10
+  };
+}

package/dist/parser/expression-parser.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Expression Parser
+ *
+ * Provides utilities for parsing JavaScript expressions in templates,
+ * using proper tokenization instead of regex-based approaches.
+ *
+ * @module parser/expression-parser
+ */
+import { extractBalancedExpression, findMatchingDelimiter, splitByPipe, Tokenizer } from './tokenizer';
+export interface ExpressionMatch {
+    fullMatch: string;
+    expression: string;
+    start: number;
+    end: number;
+    isRaw: boolean;
+}
+/**
+ * Find all template expressions in source ({{ }} and {!! !!})
+ */
+export declare function findExpressions(source: string): ExpressionMatch[];
+export interface FilterCall {
+    name: string;
+    args: string[];
+}
+export interface ParsedExpression {
+    baseExpression: string;
+    filters: FilterCall[];
+}
+/**
+ * Parse an expression with optional filter chain
+ * e.g., "value | uppercase | truncate(10)" -> { baseExpression: "value", filters: [...] }
+ */
+export declare function parseExpressionWithFilters(expression: string): ParsedExpression;
+/**
+ * Parse comma-separated arguments, respecting nesting
+ */
+export declare function parseArguments(argsString: string): string[];
+/**
+ * Extract directive parameters from parentheses
+ * e.g., "@foreach($items as $item)" -> "$items as $item"
+ */
+export declare function extractDirectiveParams(source: string, directiveEnd: number): {
+    params: string;
+    endPos: number;
+} | null;
+export interface ScriptDeclaration {
+    type: 'variable' | 'function';
+    name: string;
+    value: string;
+    exported: boolean;
+    start: number;
+    end: number;
+}
+/**
+ * Parse script content and extract declarations
+ */
+export declare function parseScriptDeclarations(scriptContent: string): ScriptDeclaration[];
+export { extractBalancedExpression, findMatchingDelimiter, splitByPipe, Tokenizer };

package/dist/parser/expression-parser.js

@@ -0,0 +1,358 @@
+import { extractBalancedExpression, findMatchingDelimiter, splitByPipe, Tokenizer } from "./tokenizer.js";
+export function findExpressions(source) {
+  const results = [];
+  let pos = 0;
+  while (pos < source.length) {
+    const nextDouble = source.indexOf("{{", pos), nextRaw = source.indexOf("{!!", pos);
+    let isRaw = !1, startPos;
+    if (nextDouble === -1 && nextRaw === -1)
+      break;
+    else if (nextDouble === -1) {
+      startPos = nextRaw;
+      isRaw = !0;
+    } else if (nextRaw === -1) {
+      startPos = nextDouble;
+      isRaw = !1;
+    } else if (nextRaw < nextDouble) {
+      startPos = nextRaw;
+      isRaw = !0;
+    } else {
+      startPos = nextDouble;
+      isRaw = !1;
+    }
+    if (!isRaw && source.slice(startPos, startPos + 3) === "{{{")
+      isRaw = !0;
+    const openDelim = isRaw ? source.slice(startPos, startPos + 3) === "{{{" ? "{{{" : "{!!" : "{{", closeDelim = isRaw ? openDelim === "{{{" ? "}}}" : "!!}" : "}}", exprStart = startPos + openDelim.length, endPos = findExpressionEnd(source, exprStart, closeDelim);
+    if (endPos === -1) {
+      pos = startPos + 1;
+      continue;
+    }
+    const expression = source.slice(exprStart, endPos).trim(), fullEnd = endPos + closeDelim.length;
+    results.push({
+      fullMatch: source.slice(startPos, fullEnd),
+      expression,
+      start: startPos,
+      end: fullEnd,
+      isRaw
+    });
+    pos = fullEnd;
+  }
+  return results;
+}
+function findExpressionEnd(source, startPos, closeDelim) {
+  let pos = startPos, inString = null;
+  const depth = { paren: 0, bracket: 0, brace: 0 };
+  let inTemplateExpr = 0;
+  while (pos < source.length) {
+    const char = source[pos];
+    if ((pos > 0 ? source[pos - 1] : "") === "\\" && inString) {
+      pos++;
+      continue;
+    }
+    if ((char === '"' || char === "'") && !inString) {
+      inString = char;
+      pos++;
+      continue;
+    }
+    if (char === inString && inString !== "`") {
+      inString = null;
+      pos++;
+      continue;
+    }
+    if (char === "`" && !inString) {
+      inString = "`";
+      pos++;
+      continue;
+    }
+    if (char === "`" && inString === "`" && inTemplateExpr === 0) {
+      inString = null;
+      pos++;
+      continue;
+    }
+    if (inString === "`" && char === "$" && source[pos + 1] === "{") {
+      inTemplateExpr++;
+      pos += 2;
+      continue;
+    }
+    if (inTemplateExpr > 0) {
+      if (char === "{")
+        inTemplateExpr++;
+      else if (char === "}")
+        inTemplateExpr--;
+      pos++;
+      continue;
+    }
+    if (inString) {
+      pos++;
+      continue;
+    }
+    if (char === "(")
+      depth.paren++;
+    else if (char === ")")
+      depth.paren--;
+    else if (char === "[")
+      depth.bracket++;
+    else if (char === "]")
+      depth.bracket--;
+    else if (char === "{")
+      depth.brace++;
+    else if (char === "}")
+      depth.brace--;
+    if (depth.paren === 0 && depth.bracket === 0 && depth.brace <= 0) {
+      if (source.slice(pos, pos + closeDelim.length) === closeDelim)
+        return pos;
+    }
+    pos++;
+  }
+  return -1;
+}
+export function parseExpressionWithFilters(expression) {
+  const parts = splitByPipe(expression);
+  if (parts.length === 0)
+    return { baseExpression: "", filters: [] };
+  const baseExpression = parts[0], filters = [];
+  for (let i = 1;i < parts.length; i++) {
+    const filter = parseFilter(parts[i]);
+    if (filter)
+      filters.push(filter);
+  }
+  return { baseExpression, filters };
+}
+function parseFilter(filterExpr) {
+  const trimmed = filterExpr.trim();
+  if (!trimmed)
+    return null;
+  const parenIndex = trimmed.indexOf("(");
+  if (parenIndex === -1)
+    return { name: trimmed, args: [] };
+  const name = trimmed.slice(0, parenIndex).trim(), argsStart = parenIndex + 1, argsEnd = findMatchingDelimiter(trimmed, "(", ")", parenIndex);
+  if (argsEnd === -1)
+    return { name, args: [] };
+  const argsString = trimmed.slice(argsStart, argsEnd), args = parseArguments(argsString);
+  return { name, args };
+}
+export function parseArguments(argsString) {
+  const args = [];
+  let current = "";
+  const depth = { paren: 0, bracket: 0, brace: 0 };
+  let inString = null, inTemplateExpr = 0;
+  for (let i = 0;i < argsString.length; i++) {
+    const char = argsString[i];
+    if ((i > 0 ? argsString[i - 1] : "") === "\\" && inString) {
+      current += char;
+      continue;
+    }
+    if ((char === '"' || char === "'") && !inString) {
+      inString = char;
+      current += char;
+      continue;
+    }
+    if (char === inString && inString !== "`") {
+      inString = null;
+      current += char;
+      continue;
+    }
+    if (char === "`" && !inString) {
+      inString = "`";
+      current += char;
+      continue;
+    }
+    if (char === "`" && inString === "`" && inTemplateExpr === 0) {
+      inString = null;
+      current += char;
+      continue;
+    }
+    if (inString === "`" && char === "$" && argsString[i + 1] === "{") {
+      inTemplateExpr++;
+      current += "${";
+      i++;
+      continue;
+    }
+    if (inTemplateExpr > 0 && char === "{") {
+      inTemplateExpr++;
+      current += char;
+      continue;
+    }
+    if (inTemplateExpr > 0 && char === "}") {
+      inTemplateExpr--;
+      current += char;
+      continue;
+    }
+    if (inString) {
+      current += char;
+      continue;
+    }
+    if (char === "(")
+      depth.paren++;
+    else if (char === ")")
+      depth.paren--;
+    else if (char === "[")
+      depth.bracket++;
+    else if (char === "]")
+      depth.bracket--;
+    else if (char === "{")
+      depth.brace++;
+    else if (char === "}")
+      depth.brace--;
+    if (char === "," && depth.paren === 0 && depth.bracket === 0 && depth.brace === 0) {
+      args.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim())
+    args.push(current.trim());
+  return args;
+}
+export function extractDirectiveParams(source, directiveEnd) {
+  let pos = directiveEnd;
+  while (pos < source.length && /\s/.test(source[pos]))
+    pos++;
+  if (source[pos] !== "(")
+    return null;
+  const closePos = findMatchingDelimiter(source, "(", ")", pos);
+  if (closePos === -1)
+    return null;
+  return {
+    params: source.slice(pos + 1, closePos),
+    endPos: closePos + 1
+  };
+}
+export function parseScriptDeclarations(scriptContent) {
+  const declarations = [], tokens = new Tokenizer(scriptContent).tokenize().filter((t) => t.type !== "WHITESPACE" && t.type !== "COMMENT");
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    let exported = !1;
+    if (token.type === "IDENTIFIER" && token.value === "export") {
+      exported = !0;
+      i++;
+      if (i >= tokens.length)
+        break;
+    }
+    const current = tokens[i];
+    if (current.type === "IDENTIFIER" && (current.value === "const" || current.value === "let" || current.value === "var")) {
+      const declType = current.value;
+      i++;
+      if (i >= tokens.length)
+        break;
+      const nameToken = tokens[i];
+      if (nameToken.type === "IDENTIFIER") {
+        const name = nameToken.value;
+        i++;
+        if (i < tokens.length && tokens[i].type === "OPERATOR" && tokens[i].value === "=") {
+          i++;
+          const valueStart = i < tokens.length ? tokens[i].start : scriptContent.length, valueResult = extractValueFromTokens(tokens, i, scriptContent);
+          i = valueResult.nextIndex;
+          declarations.push({
+            type: "variable",
+            name,
+            value: scriptContent.slice(valueStart, valueResult.endPos),
+            exported,
+            start: current.start,
+            end: valueResult.endPos
+          });
+        }
+      } else if (nameToken.type === "PUNCTUATION" && (nameToken.value === "{" || nameToken.value === "[")) {
+        const patternStart = nameToken.start, closeChar = nameToken.value === "{" ? "}" : "]", closePos = findMatchingDelimiter(scriptContent, nameToken.value, closeChar, patternStart);
+        if (closePos !== -1) {
+          const pattern = scriptContent.slice(patternStart, closePos + 1);
+          i = findTokenIndexAtPosition(tokens, closePos + 1);
+          if (i < tokens.length && tokens[i].type === "OPERATOR" && tokens[i].value === "=") {
+            i++;
+            const valueStart = i < tokens.length ? tokens[i].start : scriptContent.length, valueResult = extractValueFromTokens(tokens, i, scriptContent);
+            i = valueResult.nextIndex;
+            const uniqueName = `__stx_destructured_${declarations.length}`;
+            declarations.push({
+              type: "variable",
+              name: uniqueName,
+              value: `${scriptContent.slice(valueStart, valueResult.endPos)}; ${declType} ${pattern} = ${uniqueName}`,
+              exported,
+              start: current.start,
+              end: valueResult.endPos
+            });
+          }
+        }
+      }
+    } else if (current.type === "IDENTIFIER" && current.value === "function") {
+      const funcStart = exported ? tokens[i - 1].start : current.start;
+      i++;
+      if (i >= tokens.length)
+        break;
+      const nameToken = tokens[i];
+      if (nameToken.type === "IDENTIFIER") {
+        const name = nameToken.value;
+        i++;
+        let bodyStart = -1;
+        while (i < tokens.length) {
+          if (tokens[i].type === "PUNCTUATION" && tokens[i].value === "{") {
+            bodyStart = tokens[i].start;
+            break;
+          }
+          i++;
+        }
+        if (bodyStart !== -1) {
+          const bodyEnd = findMatchingDelimiter(scriptContent, "{", "}", bodyStart);
+          if (bodyEnd !== -1) {
+            declarations.push({
+              type: "function",
+              name,
+              value: scriptContent.slice(funcStart, bodyEnd + 1).replace(/^export\s+/, ""),
+              exported,
+              start: funcStart,
+              end: bodyEnd + 1
+            });
+            i = findTokenIndexAtPosition(tokens, bodyEnd + 1);
+          }
+        }
+      }
+    } else
+      i++;
+  }
+  return declarations;
+}
+function extractValueFromTokens(tokens, startIndex, source) {
+  let i = startIndex;
+  const depth = { paren: 0, bracket: 0, brace: 0 };
+  let endPos = startIndex < tokens.length ? tokens[startIndex].start : source.length;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.type === "PUNCTUATION") {
+      if (token.value === "(")
+        depth.paren++;
+      else if (token.value === ")")
+        depth.paren--;
+      else if (token.value === "[")
+        depth.bracket++;
+      else if (token.value === "]")
+        depth.bracket--;
+      else if (token.value === "{")
+        depth.brace++;
+      else if (token.value === "}")
+        depth.brace--;
+      if (token.value === ";" && depth.paren === 0 && depth.bracket === 0 && depth.brace === 0) {
+        endPos = token.start;
+        i++;
+        break;
+      }
+    }
+    if (token.type === "IDENTIFIER" && (token.value === "const" || token.value === "let" || token.value === "var" || token.value === "function" || token.value === "export")) {
+      if (depth.paren === 0 && depth.bracket === 0 && depth.brace === 0) {
+        endPos = tokens[i - 1]?.end ?? token.start;
+        break;
+      }
+    }
+    endPos = token.end;
+    i++;
+  }
+  return { nextIndex: i, endPos };
+}
+function findTokenIndexAtPosition(tokens, position) {
+  for (let i = 0;i < tokens.length; i++)
+    if (tokens[i].start >= position)
+      return i;
+  return tokens.length;
+}
+
+export { extractBalancedExpression, findMatchingDelimiter, splitByPipe, Tokenizer };

package/dist/parser/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Parser Module
+ *
+ * Provides tokenization and expression parsing utilities for the stx framework.
+ * This module replaces regex-based parsing with proper tokenization for better
+ * handling of nested structures, strings, and template expressions.
+ *
+ * @module parser
+ */
+export { type ConditionalBranch, type DirectiveMatch, extractParenthesizedExpression, findDirectiveBlocks, findIfBlocks, findMatchingEndTag, parseConditionalBlock, type ParsedConditional, type ParsedSwitch, parseSwitchBlock, type SwitchCase, } from './directive-parser';
+export { type ExpressionMatch, extractDirectiveParams, type FilterCall, findExpressions, parseArguments, type ParsedExpression, parseExpressionWithFilters, parseScriptDeclarations, type ScriptDeclaration, } from './expression-parser';
+export { type Token, Tokenizer, type TokenizerState, type TokenType, } from './tokenizer';
+export { extractBalancedExpression, findMatchingDelimiter, splitByPipe, } from './tokenizer';

package/dist/parser/index.js

@@ -0,0 +1,23 @@
+export {
+  extractParenthesizedExpression,
+  findDirectiveBlocks,
+  findIfBlocks,
+  findMatchingEndTag,
+  parseConditionalBlock,
+  parseSwitchBlock
+} from "./directive-parser.js";
+export {
+  extractDirectiveParams,
+  findExpressions,
+  parseArguments,
+  parseExpressionWithFilters,
+  parseScriptDeclarations
+} from "./expression-parser.js";
+export {
+  Tokenizer
+} from "./tokenizer.js";
+export {
+  extractBalancedExpression,
+  findMatchingDelimiter,
+  splitByPipe
+} from "./tokenizer.js";