@shapeshift-labs/frontier-lang-parser 0.3.60 → 0.3.62

package/dist/index.js

@@ -303,12 +303,17 @@ function readTypeFields(body) {
 }
 function readVariants(body) {
   const variants = [];
+  const seenNames = new Set();
+  const seenIds = new Set();
   const re = /^\s*variant\s+([A-Za-z_$][\w$]*)(.*)$/gm;
   let match;
   while ((match = re.exec(body))) {
     const fields = readVariantPayloadFields(match[2] ?? '', match[1], parseTypeExpression);
     if (fields === null) continue;
     const id = /@id\(\s*["']([^"']+)["']\s*\)/.exec(match[2] ?? '')?.[1];
+    const variantId = id ?? `type_variant_${safeId(match[1])}`;
+    if (seenNames.has(match[1]) || seenIds.has(variantId)) continue;
+    seenNames.add(match[1]); seenIds.add(variantId);
     variants.push({ ...(id ? { id } : {}), name: match[1], ...(fields?.length ? { fields } : {}) });
   }
   return variants.length ? variants : undefined;

package/dist/source-syntax-children.js

@@ -1,39 +1,58 @@
 import { readActionSyntaxChildren } from './action-syntax-children.js';
 import { ROW_SYNTAX_CONFIG } from './source-syntax-row-config.js';
+import { readTypeExpressionSyntaxChildren } from './source-syntax-type-expressions.js';
+import { inspectTypeExpressionSyntax } from './type-expressions.js';
 import { inspectVariantPayload } from './type-variants.js';
 
 const ROW_NAME_PATTERN = '([A-Za-z_$@./:*+-][\\w$./@:*+-]*)';
 
 export function readSourceSyntaxChildren(source, block, options = {}) {
+  let children = [];
   if (block.malformed) return [];
   if (block.kind === 'action') {
-    return readActionSyntaxChildren(source, block, options);
+    children = readActionSyntaxChildren(source, block, options);
+  } else if (block.kind === 'conversion' || block.kind === 'universalConversionPlan') {
+    children = readConversionSyntaxChildren(source, block, options);
+  } else if (block.kind === 'type') {
+    children = readTypeSyntaxChildren(source, block, options);
+  } else {
+    const rowConfig = ROW_SYNTAX_CONFIG[block.kind];
+    if (rowConfig) children = readGenericRowSyntaxChildren(source, block, options, rowConfig);
   }
-  if (block.kind === 'conversion' || block.kind === 'universalConversionPlan') {
-    return readConversionSyntaxChildren(source, block, options);
-  }
-  if (block.kind === 'type') {
-    return readTypeSyntaxChildren(source, block, options);
-  }
-  const rowConfig = ROW_SYNTAX_CONFIG[block.kind];
-  if (rowConfig) return readGenericRowSyntaxChildren(source, block, options, rowConfig);
-  return [];
+  return [...children, ...readTypeExpressionSyntaxChildren(source, block, options)];
 }
 
 function readTypeSyntaxChildren(source, block, options) {
   const children = [];
+  const seenVariantNames = new Set();
+  const seenVariantIds = new Set();
   for (const line of readBodyLines(source, block)) {
     if (!line.text || line.text.startsWith('#')) continue;
     const variant = /^variant\s+([A-Za-z_$][\w$]*)(.*)$/.exec(line.text);
     if (!variant) continue;
     const [, name, rest] = variant;
-    const payload = inspectVariantPayload(rest ?? '');
+    const payload = inspectVariantPayload(rest ?? '', inspectTypeExpressionSyntax);
+    const id = idFrom(rest, `type_variant_${safeId(name)}`);
+    let recognized = payload.ok;
+    let reason = payload.ok ? undefined : payload.reason;
+    if (recognized && seenVariantNames.has(name)) {
+      recognized = false;
+      reason = 'duplicate-type-variant-name';
+    }
+    if (recognized && seenVariantIds.has(id)) {
+      recognized = false;
+      reason = 'duplicate-type-variant-id';
+    }
+    if (recognized) {
+      seenVariantNames.add(name);
+      seenVariantIds.add(id);
+    }
     children.push(cleanRecord({
       kind: 'typeVariant',
       rowKind: 'variant',
       normalizedRowKind: 'variant',
       name,
-      id: idFrom(rest, `type_variant_${safeId(name)}`),
+      id,
       header: line.text,
       startOffset: line.startOffset,
       endOffset: line.endOffset,
@@ -44,8 +63,8 @@ function readTypeSyntaxChildren(source, block, options) {
       moduleId: block.moduleId,
       moduleName: block.moduleName,
       sourceSpan: sourceSpan(source, block, line.startOffset, line.endOffset, options),
-      recognized: payload.ok,
-      reason: payload.ok ? undefined : payload.reason,
+      recognized,
+      reason,
       fieldCount: payload.fieldCount,
       fieldIds: payload.fieldIds
     }));

package/dist/source-syntax-type-expressions.js

@@ -0,0 +1,172 @@
+import { inspectTypeExpressionSyntax } from './type-expressions.js';
+
+export function readTypeExpressionSyntaxChildren(source, block, options = {}) {
+  const children = [];
+  for (const line of readBodyLines(source, block)) {
+    if (!line.text || line.text.startsWith('#')) continue;
+    for (const candidate of readTypeExpressionCandidates(block, line.text)) {
+      const inspected = inspectTypeExpressionSyntax(candidate.typeSource);
+      if (inspected.ok) continue;
+      children.push(cleanRecord({
+        kind: 'typeExpressionSyntax',
+        rowKind: candidate.rowKind,
+        normalizedRowKind: candidate.rowKind,
+        name: candidate.name,
+        id: `${block.id ?? block.kind}_${candidate.rowKind}_${safeId(candidate.name)}_${line.startOffset}`,
+        header: line.text,
+        startOffset: line.startOffset,
+        endOffset: line.endOffset,
+        location: sourcePosition(source, line.startOffset),
+        parentKind: block.kind,
+        parentId: block.id,
+        parentName: block.name,
+        moduleId: block.moduleId,
+        moduleName: block.moduleName,
+        sourceSpan: sourceSpan(source, block, line.startOffset, line.endOffset, options),
+        recognized: false,
+        reason: inspected.reason,
+        typeSource: candidate.typeSource
+      }));
+    }
+  }
+  return children;
+}
+
+function readTypeExpressionCandidates(block, text) {
+  if (block.kind === 'type') return readTypeBlockTypeExpressionCandidates(block, text);
+  if (block.kind === 'entity') return readNamedTypeFieldCandidate(text, 'field', { stopAtMetadata: true });
+  if (block.kind === 'state') return readNamedTypeFieldCandidate(text, 'collection', { stopAtMetadata: true });
+  if (block.kind === 'view') return readViewTypeExpressionCandidates(text);
+  if (block.kind === 'action' || block.kind === 'effect' || block.kind === 'capability' || block.kind === 'extern') {
+    return readSignatureTypeExpressionCandidates(text);
+  }
+  if (block.kind === 'lattice') return readCarrierTypeExpressionCandidate(text);
+  return [];
+}
+
+function readTypeBlockTypeExpressionCandidates(block, text) {
+  const alias = /^=\s*(.+)$/.exec(text);
+  if (alias) return [{ rowKind: 'typeAlias', name: block.name ?? 'alias', typeSource: alias[1].trim() }];
+  if (text.startsWith('variant ')) return [];
+  return readNamedTypeFieldCandidate(text, 'typeField');
+}
+
+function readViewTypeExpressionCandidates(text) {
+  const prop = /^prop\s+([A-Za-z_$][\w$.-]*)(?:\s+@id\(\s*["'][^"']+["']\s*\))?\s*:\s*(.+)$/.exec(text);
+  if (prop) {
+    const typeSource = prop[2].replace(/\s+optional\s*$/, '').trim();
+    return typeSource ? [{ rowKind: 'viewProp', name: prop[1], typeSource }] : [];
+  }
+  const event = /^event\s+([A-Za-z_$][\w$.-]*)(?:\s+@id\(\s*["'][^"']+["']\s*\))?(.*)$/.exec(text);
+  if (!event) return [];
+  const input = readInlineType('input', event[2]);
+  return input ? [{ rowKind: 'viewEventInput', name: event[1], typeSource: input }] : [];
+}
+
+function readSignatureTypeExpressionCandidates(text) {
+  const input = /^input\s*:?\s*(.+)$/.exec(text);
+  if (input) return [{ rowKind: 'input', name: 'input', typeSource: input[1].trim() }];
+  const returns = /^returns\s+(.+)$/.exec(text);
+  if (returns) return [{ rowKind: 'returns', name: 'returns', typeSource: returns[1].trim() }];
+  return [];
+}
+
+function readCarrierTypeExpressionCandidate(text) {
+  const carrier = /^carrier\s+(.+)$/.exec(text);
+  return carrier ? [{ rowKind: 'carrier', name: 'carrier', typeSource: carrier[1].trim() }] : [];
+}
+
+function readNamedTypeFieldCandidate(text, rowKind, options = {}) {
+  const field = /^([A-Za-z_$][\w$]*)(?:\s+@id\(\s*["'][^"']+["']\s*\))?\s*:\s*(.+)$/.exec(text);
+  if (!field) return [];
+  const typeSource = options.stopAtMetadata ? readTypeSourceBeforeMetadata(field[2]) : field[2].trim();
+  return typeSource ? [{ rowKind, name: field[1], typeSource }] : [];
+}
+
+function readTypeSourceBeforeMetadata(source) {
+  let stack = [];
+  let quote = '';
+  let escaped = false;
+  for (let index = 0; index < source.length; index++) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === quote) {
+        quote = '';
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (stack.length === 0 && char === '{') return source.slice(0, index).trim();
+    if (char === '<' || char === '(' || char === '[' || char === '{') {
+      stack.push(closingDelimiterFor(char));
+      continue;
+    }
+    if (char === '>' || char === ')' || char === ']' || char === '}') {
+      if (stack[stack.length - 1] === char) stack = stack.slice(0, -1);
+      continue;
+    }
+    if (stack.length === 0 && /\s/.test(char) && source.slice(index).trimStart().startsWith('@')) {
+      return source.slice(0, index).trim();
+    }
+  }
+  return source.trim();
+}
+
+function readBodyLines(source, block) {
+  return readTextLines(source, block.bodyStartOffset, block.bodyEndOffset);
+}
+
+function readTextLines(source, startOffset, endOffset) {
+  const body = source.slice(startOffset, endOffset);
+  const lines = body.split('\n');
+  const records = [];
+  let lineStart = startOffset;
+  for (const rawLine of lines) {
+    const rawEnd = lineStart + rawLine.length;
+    const leading = /^\s*/.exec(rawLine)?.[0].length ?? 0;
+    const trailing = /\s*$/.exec(rawLine)?.[0].length ?? 0;
+    const startOffset = lineStart + leading;
+    const endOffset = Math.max(startOffset, rawEnd - trailing);
+    records.push({ text: rawLine.trim(), startOffset, endOffset });
+    lineStart = rawEnd + 1;
+  }
+  return records;
+}
+
+function sourcePosition(source, offset) {
+  const lines = source.slice(0, offset).split('\n');
+  return { line: lines.length, column: lines[lines.length - 1].length + 1, offset };
+}
+
+function sourceSpan(source, block, startOffset, endOffset, options = {}) {
+  return cleanRecord({
+    sourceId: options.documentId,
+    path: options.sourcePath,
+    blockId: block.id,
+    blockKind: block.kind,
+    startOffset,
+    endOffset,
+    start: sourcePosition(source, startOffset),
+    end: sourcePosition(source, endOffset)
+  });
+}
+
+function readInlineType(label, text = '') { return new RegExp('(?:^|\\s)' + label + '\\s+(.+)$').exec(text)?.[1]?.trim(); }
+function safeId(value) { return String(value).replace(/[^A-Za-z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'row'; }
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}
+
+function closingDelimiterFor(char) {
+  if (char === '<') return '>';
+  if (char === '(') return ')';
+  if (char === '[') return ']';
+  return '}';
+}

package/dist/type-expressions.js

@@ -8,17 +8,38 @@ export function parseTypeExpression(value) {
   const text = value.trim();
   const application = readTypeApplication(text);
   if (!application) return text;
+  if (application.name === 'Record') return readRecordTypeExpression(application.body) ?? text;
+  if (application.name === 'Union') return readUnionTypeExpression(application.body) ?? text;
   const args = splitTopLevelCommaList(application.body);
   if (args.some((arg) => !arg)) return text;
   const parsedArgs = args.map(parseTypeExpression);
   if (application.name === 'Set' && parsedArgs.length === 1) return { kind: 'set', item: parsedArgs[0] };
   if (application.name === 'List' && parsedArgs.length === 1) return { kind: 'list', item: parsedArgs[0] };
   if (application.name === 'Map' && parsedArgs.length === 2) return { kind: 'map', key: parsedArgs[0], value: parsedArgs[1] };
-  if (application.name === 'Record') return readRecordTypeExpression(application.body) ?? { kind: 'ref', name: application.name, args: parsedArgs };
-  if (application.name === 'Union') return readUnionTypeExpression(application.body) ?? { kind: 'ref', name: application.name, args: parsedArgs };
   return { kind: 'ref', name: application.name, args: parsedArgs };
 }
 
+export function inspectTypeExpressionSyntax(value) {
+  const text = value.trim();
+  if (!text) return { ok: false, reason: 'missing-type-expression' };
+  const application = readTypeApplication(text);
+  if (!application) {
+    return hasReservedStructuralTypeSyntax(text)
+      ? { ok: false, reason: 'malformed-structural-type-expression' }
+      : { ok: true };
+  }
+  if (application.name === 'Record') return inspectRecordTypeExpression(application.body);
+  if (application.name === 'Union') return inspectUnionTypeExpression(application.body);
+  if (!hasReservedStructuralTypeSyntax(application.body)) return { ok: true };
+  const args = splitTopLevelCommaListStrict(application.body);
+  if (!args.ok) return { ok: false, reason: args.reason };
+  for (const arg of args.parts) {
+    const inspected = inspectTypeExpressionSyntax(arg);
+    if (!inspected.ok) return inspected;
+  }
+  return { ok: true };
+}
+
 function readTypeApplication(text) {
   const match = /^([A-Za-z_$][\w$]*)</.exec(text);
   if (!match || !text.endsWith('>')) return undefined;
@@ -35,34 +56,98 @@ function readTypeApplication(text) {
 }
 
 function readRecordTypeExpression(body) {
+  const split = splitTopLevelCommaListStrict(body);
+  if (!split.ok) return undefined;
   const fields = [];
-  for (const source of splitTopLevelCommaList(body)) {
+  const seen = new Set();
+  const seenNames = new Set();
+  for (const source of split.parts) {
     const field = readInlineTypeField(source, 'record_field');
     if (!field) return undefined;
+    if (seen.has(field.id)) return undefined;
+    seen.add(field.id);
+    if (seenNames.has(field.name)) return undefined;
+    seenNames.add(field.name);
     fields.push(field);
   }
   return fields.length ? { kind: 'record', fields } : undefined;
 }
 
 function readUnionTypeExpression(body) {
+  const split = splitTopLevelCommaListStrict(body);
+  if (!split.ok) return undefined;
   const variants = [];
-  for (const source of splitTopLevelCommaList(body)) {
+  const seenNames = new Set();
+  const seenIds = new Set();
+  for (const source of split.parts) {
     const variant = readInlineTypeVariant(source);
     if (!variant) return undefined;
+    if (seenNames.has(variant.name)) return undefined;
+    seenNames.add(variant.name);
+    if (variant.id) {
+      if (seenIds.has(variant.id)) return undefined;
+      seenIds.add(variant.id);
+    }
     variants.push(variant);
   }
   return variants.length ? { kind: 'union', variants } : undefined;
 }
 
+function inspectRecordTypeExpression(body) {
+  const split = splitTopLevelCommaListStrict(body);
+  if (!split.ok) return { ok: false, reason: split.reason };
+  if (!split.parts.length) return { ok: false, reason: 'empty-structural-record-type' };
+  const seen = new Set();
+  const seenNames = new Set();
+  for (const source of split.parts) {
+    const field = readInlineTypeField(source, 'record_field');
+    if (!field) return { ok: false, reason: 'malformed-structural-record-field' };
+    if (seen.has(field.id)) return { ok: false, reason: 'duplicate-structural-record-field-id' };
+    seen.add(field.id);
+    if (seenNames.has(field.name)) return { ok: false, reason: 'duplicate-structural-record-field-name' };
+    seenNames.add(field.name);
+  }
+  return { ok: true, fieldCount: split.parts.length };
+}
+
+function inspectUnionTypeExpression(body) {
+  const split = splitTopLevelCommaListStrict(body);
+  if (!split.ok) return { ok: false, reason: split.reason };
+  if (!split.parts.length) return { ok: false, reason: 'empty-structural-union-type' };
+  const seenNames = new Set();
+  const seenIds = new Set();
+  for (const source of split.parts) {
+    const inspected = inspectInlineTypeVariant(source);
+    if (!inspected.ok) return inspected;
+    const variant = readInlineTypeVariant(source);
+    if (seenNames.has(variant.name)) return { ok: false, reason: 'duplicate-structural-union-variant-name' };
+    seenNames.add(variant.name);
+    if (variant.id) {
+      if (seenIds.has(variant.id)) return { ok: false, reason: 'duplicate-structural-union-variant-id' };
+      seenIds.add(variant.id);
+    }
+  }
+  return { ok: true, variantCount: split.parts.length };
+}
+
 function readInlineTypeVariant(source) {
   const match = /^\s*([A-Za-z_$][\w$]*)(?:\s+@id\(\s*["']([^"']+)["']\s*\))?(?:\((.*)\))?\s*$/.exec(source);
   if (!match) return undefined;
   const payload = match[3]?.trim();
   const fields = [];
-  if (payload) {
-    for (const fieldSource of splitTopLevelCommaList(payload)) {
+  if (match[3] !== undefined) {
+    if (!payload) return undefined;
+    const split = splitTopLevelCommaListStrict(payload);
+    if (!split.ok) return undefined;
+    const seen = new Set();
+    const seenNames = new Set();
+    for (const fieldSource of split.parts) {
       const field = readInlineTypeField(fieldSource, `variant_field_${match[1]}`);
       if (!field) return undefined;
+      if (seen.has(field.id)) return undefined;
+      seen.add(field.id);
+      if (seenNames.has(field.name)) return undefined;
+      seenNames.add(field.name);
       fields.push(field);
     }
   }
@@ -73,14 +158,92 @@ function readInlineTypeVariant(source) {
   };
 }
 
+function inspectInlineTypeVariant(source) {
+  const match = /^\s*([A-Za-z_$][\w$]*)(?:\s+@id\(\s*["']([^"']+)["']\s*\))?(?:\((.*)\))?\s*$/.exec(source);
+  if (!match) return { ok: false, reason: 'malformed-structural-union-variant' };
+  const payload = match[3]?.trim();
+  if (match[3] === undefined) return { ok: true };
+  if (!payload) return { ok: false, reason: 'empty-structural-union-variant-payload' };
+  const split = splitTopLevelCommaListStrict(payload);
+  if (!split.ok) return { ok: false, reason: split.reason };
+  const seen = new Set();
+  const seenNames = new Set();
+  for (const fieldSource of split.parts) {
+    const field = readInlineTypeField(fieldSource, `variant_field_${match[1]}`);
+    if (!field) return { ok: false, reason: 'malformed-structural-union-variant-field' };
+    if (seen.has(field.id)) return { ok: false, reason: 'duplicate-structural-union-variant-field-id' };
+    seen.add(field.id);
+    if (seenNames.has(field.name)) return { ok: false, reason: 'duplicate-structural-union-variant-field-name' };
+    seenNames.add(field.name);
+  }
+  return { ok: true };
+}
+
 function readInlineTypeField(source, idPrefix) {
   const match = /^\s*([A-Za-z_$][\w$]*)(\?)?(?:\s+@id\(\s*["']([^"']+)["']\s*\))?(\?)?\s*:\s*(.+)\s*$/.exec(source);
   if (!match || !match[5].trim()) return undefined;
+  const typeSource = match[5].trim();
+  if (!inspectTypeExpressionSyntax(typeSource).ok) return undefined;
   const optional = Boolean(match[2] || match[4]);
   return {
     id: match[3] ?? `${idPrefix}_${match[1]}`,
     name: match[1],
-    type: parseTypeExpression(match[5].trim()),
+    type: parseTypeExpression(typeSource),
     ...(optional ? { optional: true } : {})
   };
 }
+
+function hasReservedStructuralTypeSyntax(text) {
+  return /\b(?:Record|Union)\s*</.test(text);
+}
+
+function splitTopLevelCommaListStrict(source) {
+  const parts = [];
+  const stack = [];
+  let start = 0;
+  let quote = '';
+  let escaped = false;
+  for (let index = 0; index < source.length; index++) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === quote) {
+        quote = '';
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === '<' || char === '(' || char === '[' || char === '{') {
+      stack.push(closingDelimiterFor(char));
+      continue;
+    }
+    if (char === '>' || char === ')' || char === ']' || char === '}') {
+      if (stack.pop() !== char) return { ok: false, reason: 'unbalanced-structural-type-expression' };
+      continue;
+    }
+    if (char === ',' && stack.length === 0) {
+      const part = source.slice(start, index).trim();
+      if (!part) return { ok: false, reason: 'empty-structural-type-expression-part' };
+      parts.push(part);
+      start = index + 1;
+    }
+  }
+  if (quote || stack.length) return { ok: false, reason: 'unbalanced-structural-type-expression' };
+  const last = source.slice(start).trim();
+  if (!last) return { ok: false, reason: 'empty-structural-type-expression-part' };
+  parts.push(last);
+  return { ok: true, parts };
+}
+
+function closingDelimiterFor(char) {
+  if (char === '<') return '>';
+  if (char === '(') return ')';
+  if (char === '[') return ']';
+  return '}';
+}

package/dist/type-variants.js

@@ -12,18 +12,24 @@ export function readVariantPayloadFields(rest, variantName, parseTypeExpression)
   return fields;
 }
 
-export function inspectVariantPayload(rest) {
+export function inspectVariantPayload(rest, inspectTypeExpressionSyntax) {
   const withoutId = stripLeadingVariantId(rest);
   if (!withoutId) return { ok: true };
   const payload = /^\((.*)\)$/.exec(withoutId);
   if (!payload || !payload[1].trim()) return { ok: false, reason: 'malformed-type-variant-payload' };
   const fieldIds = [];
   const seen = new Set();
+  const seenNames = new Set();
   for (const fieldSource of splitTopLevelCommaList(payload[1])) {
     const field = parseVariantPayloadField(fieldSource);
     if (!field) return { ok: false, reason: 'malformed-type-variant-payload' };
     if (seen.has(field.id)) return { ok: false, reason: 'duplicate-type-variant-field-id' };
     seen.add(field.id);
+    if (seenNames.has(field.name)) return { ok: false, reason: 'duplicate-type-variant-field-name' };
+    seenNames.add(field.name);
+    const typeSource = readVariantPayloadFieldTypeSource(fieldSource);
+    const inspected = inspectTypeExpressionSyntax?.(typeSource);
+    if (inspected && !inspected.ok) return { ok: false, reason: inspected.reason };
     fieldIds.push(field.id);
   }
   return { ok: true, fieldCount: fieldIds.length, fieldIds };
@@ -41,6 +47,10 @@ function parseVariantPayloadField(source, variantName, parseTypeExpression) {
   };
 }
 
+function readVariantPayloadFieldTypeSource(source) {
+  return /^\s*[A-Za-z_$][\w$]*(\?)?(?:\s+@id\(\s*["'][^"']+["']\s*\))?(\?)?\s*:\s*(.+)\s*$/.exec(source)?.[3]?.trim();
+}
+
 export function splitTopLevelCommaList(source) {
   const parts = [];
   let depth = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.60",
+  "version": "0.3.62",
   "description": "Parser for the first Frontier Lang .frontier syntax slice.",
   "type": "module",
   "main": "./dist/index.js",