@shapeshift-labs/frontier-lang-compiler 0.2.149 → 0.2.151

package/dist/internal/index-impl/sourceMapGeneratedBoundaryGate.js

@@ -0,0 +1,185 @@
+import { countBy, uniqueStrings } from '../../native-import-utils.js';
+
+export function classifySourceMapGeneratedBoundary(sourceMaps, options = {}) {
+  const maps = normalizeSourceMapCollection(sourceMaps);
+  const entries = maps.flatMap((sourceMap) => (sourceMap?.mappings ?? [])
+    .map((mapping) => ({ sourceMap, mapping })));
+  const exactEntries = entries.filter(({ sourceMap, mapping }) => hasExactGeneratedBoundary(sourceMap, mapping));
+  const generatedBoundaryOwnershipRecords = exactEntries.map(generatedBoundaryOwnershipRecord).filter(Boolean);
+  const summary = sourceMapGeneratedBoundarySummary(maps, entries);
+  const exactBoundary = generatedBoundaryOwnershipRecords.length > 0;
+  return {
+    schema: 'frontier.lang.sourceMapGeneratedBoundaryGate.v1',
+    version: 1,
+    status: exactBoundary ? 'ready' : 'blocked',
+    readiness: exactBoundary ? 'ready' : 'blocked',
+    action: exactBoundary ? 'admit-exact-source-map-generated-boundary' : 'block-generated-file-merge-admission',
+    reviewRequired: !exactBoundary,
+    exactBoundary,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    sourceLanguage: options.sourceLanguage,
+    target: options.target,
+    outputMode: options.outputMode,
+    projectionMode: options.projectionMode,
+    sourceMapIds: uniqueStrings(maps.map((sourceMap) => sourceMap?.id)),
+    sourceMapMappingIds: uniqueStrings(exactEntries.map(({ mapping }) => mapping?.id)),
+    generatedBoundaryOwnershipStatus: exactBoundary ? 'deterministic-source-map-span' : 'blocked',
+    generatedBoundaryOwnershipKeys: uniqueStrings(generatedBoundaryOwnershipRecords.map((record) => record.key)),
+    generatedBoundaryOwnershipRecords,
+    invariant: 'ECMA-426 source maps identify generated positions and original positions; Frontier generated-file merge admission requires validated source-map evidence plus exact source and generated spans with source and target hashes.',
+    missingInvariant: exactBoundary ? undefined : 'ecma-426-generated-position-only-no-range-boundary',
+    summary,
+    reasonCodes: sourceMapGeneratedBoundaryReasonCodes(summary, exactBoundary)
+  };
+}
+
+function normalizeSourceMapCollection(sourceMaps) {
+  if (!sourceMaps) return [];
+  return Array.isArray(sourceMaps) ? sourceMaps.filter(Boolean) : [sourceMaps].filter(Boolean);
+}
+
+function hasExactGeneratedBoundary(sourceMap, mapping) {
+  return mapping?.precision === 'exact'
+    && hasExactSpan(mapping.sourceSpan)
+    && hasExactSpan(mapping.generatedSpan)
+    && Boolean(sourceBoundaryHash(sourceMap, mapping))
+    && Boolean(targetBoundaryHash(sourceMap, mapping));
+}
+
+function hasExactSpan(span) {
+  if (!span) return false;
+  return [span.startLine, span.startColumn, span.endLine, span.endColumn]
+    .every((value) => Number.isFinite(value));
+}
+
+function sourceMapGeneratedBoundarySummary(maps, entries) {
+  const mappings = entries.map(({ mapping }) => mapping);
+  const ecma426Payloads = maps.map(ecma426SourceMapEvidence).filter((record) => record?.present);
+  const ecma426ReasonCodes = uniqueStrings(ecma426Payloads.flatMap((record) => record?.reasonCodes ?? []));
+  const generatedBoundaryOwnershipRecords = entries
+    .filter(({ sourceMap, mapping }) => hasExactGeneratedBoundary(sourceMap, mapping))
+    .map(generatedBoundaryOwnershipRecord)
+    .filter(Boolean);
+  return {
+    sourceMaps: maps.length,
+    mappings: mappings.length,
+    exactBoundaryMappings: entries.filter(({ sourceMap, mapping }) => hasExactGeneratedBoundary(sourceMap, mapping)).length,
+    deterministicGeneratedBoundaryOwnerships: generatedBoundaryOwnershipRecords.length,
+    exactPrecisionMappings: mappings.filter((mapping) => mapping?.precision === 'exact').length,
+    withSourceSpan: mappings.filter((mapping) => hasExactSpan(mapping?.sourceSpan)).length,
+    withGeneratedSpan: mappings.filter((mapping) => hasExactSpan(mapping?.generatedSpan)).length,
+    withSourceHash: entries.filter(({ sourceMap, mapping }) => sourceBoundaryHash(sourceMap, mapping)).length,
+    withTargetHash: entries.filter(({ sourceMap, mapping }) => targetBoundaryHash(sourceMap, mapping)).length,
+    byPrecision: countBy(mappings.map((mapping) => mapping?.precision ?? 'unknown')),
+    byOrigin: countBy(mappings.map((mapping) => mapping?.metadata?.sourceMapOrigin ?? 'native-import')),
+    byBoundaryKind: countBy(entries.map(({ sourceMap, mapping }) => sourceMapBoundaryKind(sourceMap, mapping))),
+    byEcma426Status: countBy(maps.map((sourceMap) => ecma426SourceMapEvidence(sourceMap)?.status ?? 'missing')),
+    ecma426Payloads: ecma426Payloads.length,
+    validEcma426Payloads: ecma426Payloads.filter((record) => record?.status === 'valid').length,
+    invalidEcma426Payloads: ecma426Payloads.filter((record) => record?.status === 'blocked').length,
+    decodedEcma426Mappings: ecma426Payloads.reduce((sum, record) => sum + numeric(record?.summary?.decodedMappings), 0),
+    ecma426ReasonCodes,
+    sourcePaths: uniqueStrings(entries.map(({ sourceMap, mapping }) => mapping?.sourceSpan?.path ?? sourceMap?.sourcePath)),
+    targetPaths: uniqueStrings(entries.map(({ sourceMap, mapping }) => mapping?.generatedSpan?.targetPath
+      ?? mapping?.generatedSpan?.path ?? sourceMap?.targetPath ?? sourceMap?.target?.emitPath))
+  };
+}
+
+function sourceMapGeneratedBoundaryReasonCodes(summary, exactBoundary) {
+  return uniqueStrings([
+    'ecma-426:source-map-generated-boundary-gate',
+    'runtime-neutral:source-map-records-only',
+    exactBoundary ? 'source-map-generated-boundary:exact' : 'ecma-426:missing-exact-source-generated-boundary',
+    exactBoundary ? 'source-map-generated-boundary:deterministic-source-map-span-ownership' : undefined,
+    summary.sourceMaps === 0 ? 'source-map:missing' : undefined,
+    !exactBoundary && summary.ecma426Payloads === 0 ? 'ecma-426:payload-missing' : undefined,
+    summary.validEcma426Payloads > 0 ? 'ecma-426:payload-valid' : undefined,
+    !exactBoundary && summary.invalidEcma426Payloads > 0 ? 'ecma-426:payload-invalid' : undefined,
+    !exactBoundary && summary.validEcma426Payloads > 0 && summary.exactBoundaryMappings === 0 ? 'ecma-426:payload-position-only' : undefined,
+    ...summary.ecma426ReasonCodes,
+    summary.mappings === 0 ? 'source-map:mappings-missing' : undefined,
+    summary.exactPrecisionMappings === 0 ? 'source-map:exact-precision-missing' : undefined,
+    summary.withSourceSpan < summary.mappings ? 'ecma-426:missing-original-range' : undefined,
+    summary.withGeneratedSpan < summary.mappings ? 'ecma-426:missing-generated-range' : undefined,
+    summary.withSourceHash < summary.mappings ? 'source-map:source-hash-missing' : undefined,
+    summary.withTargetHash < summary.mappings ? 'source-map:target-hash-missing' : undefined
+  ]);
+}
+
+function sourceBoundaryHash(sourceMap, mapping) {
+  return sourceMap?.sourceHash ?? mapping?.sourceSpan?.sourceHash ?? mapping?.sourceSpan?.sourceId;
+}
+
+function targetBoundaryHash(sourceMap, mapping) {
+  return sourceMap?.targetHash ?? mapping?.generatedSpan?.targetHash ?? mapping?.targetHash;
+}
+
+function generatedBoundaryOwnershipRecord({ sourceMap, mapping }) {
+  if (!hasExactGeneratedBoundary(sourceMap, mapping)) return undefined;
+  const sourceSpan = mapping?.sourceSpan;
+  const generatedSpan = mapping?.generatedSpan;
+  const sourcePath = sourceSpan?.path ?? sourceMap?.sourcePath;
+  const targetPath = generatedSpan?.targetPath ?? generatedSpan?.path ?? sourceMap?.targetPath ?? sourceMap?.target?.emitPath;
+  const sourceHash = sourceBoundaryHash(sourceMap, mapping);
+  const targetHash = targetBoundaryHash(sourceMap, mapping);
+  const sourceSpanKey = exactSpanKey(sourceSpan);
+  const generatedSpanKey = exactSpanKey(generatedSpan);
+  const key = stableKey(['generated-boundary', sourcePath, sourceHash, sourceSpanKey, targetPath, targetHash, generatedSpanKey]);
+  return compactRecord({
+    key,
+    status: 'deterministic-source-map-span',
+    sourceMapId: sourceMap?.id,
+    sourceMapMappingId: mapping?.id,
+    sourcePath,
+    targetPath,
+    sourceHash,
+    targetHash,
+    sourceSpanKey,
+    generatedSpanKey,
+    boundaryKind: sourceMapBoundaryKind(sourceMap, mapping),
+    sourceMapOrigin: mapping?.metadata?.sourceMapOrigin ?? 'native-import'
+  });
+}
+
+function exactSpanKey(span) {
+  return stableKey([
+    span?.path ?? span?.targetPath ?? span?.sourceId,
+    span?.start,
+    span?.end,
+    span?.startLine,
+    span?.startColumn,
+    span?.endLine,
+    span?.endColumn
+  ]);
+}
+
+function ecma426SourceMapEvidence(sourceMap) {
+  return sourceMap?.metadata?.ecma426SourceMap;
+}
+
+function numeric(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : 0;
+}
+
+function sourceMapBoundaryKind(sourceMap, mapping) {
+  const sourcePath = mapping?.sourceSpan?.path ?? sourceMap?.sourcePath;
+  const targetPath = mapping?.generatedSpan?.targetPath ?? mapping?.generatedSpan?.path
+    ?? sourceMap?.targetPath ?? sourceMap?.target?.emitPath;
+  const sourceHash = sourceBoundaryHash(sourceMap, mapping);
+  const targetHash = targetBoundaryHash(sourceMap, mapping);
+  if (sourcePath && targetPath && sourcePath === targetPath && sourceHash && targetHash && sourceHash === targetHash) {
+    return 'preserved-source';
+  }
+  return 'source-generated';
+}
+
+function stableKey(parts) {
+  const values = parts.map((part) => part === undefined || part === null ? '' : String(part));
+  return values.some(Boolean) ? values.join('#') : undefined;
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}

package/dist/internal/index-impl/staticMemberLiteral.js

@@ -0,0 +1,31 @@
+function readStaticMemberLiteral(sourceText, start, limit) {
+  const quote = sourceText[start];
+  if (quote === '\'' || quote === '"') return readQuotedMemberLiteral(sourceText, start, limit, quote);
+  if (quote === '`') return readTemplateMemberLiteral(sourceText, start, limit);
+  return undefined;
+}
+
+function readQuotedMemberLiteral(sourceText, start, limit, quote) {
+  let value = '';
+  for (let index = start + 1; index < limit; index += 1) {
+    const char = sourceText[index];
+    if (char === '\\' || char === '\n' || char === '\r') return undefined;
+    if (char === quote) return { value, start: start + 1, end: index, literalKind: 'string-literal' };
+    value += char;
+  }
+  return undefined;
+}
+
+function readTemplateMemberLiteral(sourceText, start, limit) {
+  let value = '';
+  for (let index = start + 1; index < limit; index += 1) {
+    const char = sourceText[index];
+    if (char === '\\' || char === '\n' || char === '\r') return undefined;
+    if (char === '$' && sourceText[index + 1] === '{') return undefined;
+    if (char === '`') return { value, start: start + 1, end: index, literalKind: 'static-template-literal' };
+    value += char;
+  }
+  return undefined;
+}
+
+export { readStaticMemberLiteral };

package/dist/internal/index-impl/staticOptionalMemberReference.js

@@ -0,0 +1,22 @@
+function staticOptionalMemberReference(text) {
+  const normalized = normalizedOptionalMemberExpression(text);
+  if (!normalized.includes('?.')) return undefined;
+  if (!/^(?:this|[A-Za-z_$][\w$]*)(?:(?:\?\.|\.)[A-Za-z_$][\w$]*)+$/.test(normalized)) return undefined;
+  const path = normalized.split(/\?\.|\./);
+  const operators = normalized.match(/\?\.|\./g) ?? [];
+  const optionalSegmentIndexes = operators.flatMap((operator, index) => operator === '?.' ? [index + 1] : []);
+  return {
+    text: normalized,
+    root: path[0],
+    path,
+    memberPath: path.slice(1),
+    optionalSegments: optionalSegmentIndexes.map((index) => path[index]),
+    optionalSegmentIndexes
+  };
+}
+
+function normalizedOptionalMemberExpression(text) {
+  return String(text ?? '').trim().replace(/\s+/g, ' ').replace(/\s*(\?\.|\.)\s*/g, '$1').replace(/\s+/g, '');
+}
+
+export { staticOptionalMemberReference };

package/dist/internal/index-impl/syntaxAstSourcePreservation.js

@@ -0,0 +1,273 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from '../../native-import-utils.js';
+import {
+  createPreservedSourceOwnershipAnchor,
+  preservedOwnershipAnchorKind,
+  preservedSourceSegmentRole
+} from '../../native-source-preservation-ownership.js';
+import { createNativeSourcePreservation } from './createNativeSourcePreservation.js';
+
+export function createSyntaxAstSourcePreservation(ast, input, options = {}) {
+  if (!ast || typeof input.sourceText !== 'string') return undefined;
+  const sourceText = input.sourceText;
+  const sourceHash = hashSemanticValue(sourceText);
+  const parserEvidence = `${options.parser ?? input.parser ?? 'syntax-ast'}-parser-token-comment-ranges`;
+  const tokensAndTrivia = syntaxAstTokensAndTrivia(ast, input, {
+    ...options,
+    parserEvidence,
+    sourceHash,
+    sourceText
+  });
+  if (!tokensAndTrivia?.exact) return undefined;
+  const adapterId = input.adapterId ?? options.adapterId ?? `${options.parser ?? input.parser ?? 'syntax'}-native-importer`;
+  return createNativeSourcePreservation({
+    language: input.language ?? options.language ?? 'javascript',
+    sourcePath: input.sourcePath,
+    sourceHash: input.sourceHash,
+    sourceText,
+    tokensAndTrivia,
+    includeTokens: options.includeTokens !== false,
+    includeTrivia: options.includeTrivia !== false,
+    parserTriviaEvidence: {
+      status: 'exact',
+      exactParserTrivia: true,
+      losslessCst: true,
+      sourceHash,
+      adapterId,
+      evidenceId: `${adapterId}:parser-token-comment:${idFragment(input.sourcePath ?? sourceHash)}`,
+      parserEvidence
+    },
+    metadata: {
+      parserTokenTriviaEvidence: parserEvidence,
+      parserTokenTriviaSource: options.astFormat ?? options.parser ?? 'syntax-ast'
+    }
+  });
+}
+
+function syntaxAstTokensAndTrivia(ast, input, options) {
+  const sourceText = options.sourceText;
+  const parserSegments = parserTokenCommentSegments(ast)
+    .map((entry, index) => segmentFromParserEntry(entry, index, input, options))
+    .filter(Boolean)
+    .sort((left, right) => left.span.start - right.span.start || left.span.end - right.span.end);
+  if (!parserSegments.length) return undefined;
+  const exact = parserSegmentsCoverSource(parserSegments, sourceText);
+  if (!exact) return { exact: false };
+  const whitespaceSegments = whitespaceTriviaSegments(parserSegments, input, options);
+  const allTrivia = [...parserSegments.filter((segment) => segment.role === 'trivia'), ...whitespaceSegments]
+    .sort((left, right) => left.span.start - right.span.start || left.span.end - right.span.end);
+  const tokens = limitRecords(parserSegments.filter((segment) => segment.role !== 'trivia'), options.maxTokens);
+  const trivia = limitRecords(allTrivia, options.maxTrivia);
+  return {
+    exact: true,
+    tokens: tokens.records,
+    trivia: trivia.records,
+    truncated: tokens.truncated || trivia.truncated,
+    parserEvidence: options.parserEvidence
+  };
+}
+
+function parserTokenCommentSegments(ast) {
+  return uniqueParserEntries([
+    ...arrayValue(ast.tokens),
+    ...arrayValue(ast.comments),
+    ...arrayValue(ast.program?.tokens),
+    ...arrayValue(ast.program?.comments)
+  ]);
+}
+
+function segmentFromParserEntry(entry, index, input, options) {
+  const range = sourceRange(entry);
+  if (!range || range.end <= range.start || range.end > options.sourceText.length) return undefined;
+  const text = options.sourceText.slice(range.start, range.end);
+  if (!parserEntrySourceTextMatches(entry, text)) return undefined;
+  const parserKind = parserEntryKind(entry);
+  const kind = entryIsComment(entry, text) ? preservedCommentKind(text) : syntaxTokenKind(parserKind, text, input.sourcePath);
+  return preservedParserSegment({
+    index,
+    kind,
+    text,
+    start: range.start,
+    end: range.end,
+    sourceHash: options.sourceHash,
+    sourcePath: input.sourcePath,
+    sourceText: options.sourceText,
+    parserEvidence: options.parserEvidence,
+    parserKind
+  });
+}
+
+function whitespaceTriviaSegments(parserSegments, input, options) {
+  const result = [];
+  let cursor = 0;
+  for (const segment of parserSegments) {
+    if (segment.span.start > cursor) {
+      result.push(...whitespaceSegmentsForText(options.sourceText.slice(cursor, segment.span.start), cursor, input, options, result.length));
+    }
+    cursor = Math.max(cursor, segment.span.end);
+  }
+  if (cursor < options.sourceText.length) {
+    result.push(...whitespaceSegmentsForText(options.sourceText.slice(cursor), cursor, input, options, result.length));
+  }
+  return result;
+}
+
+function whitespaceSegmentsForText(text, baseOffset, input, options, startIndex) {
+  const records = [];
+  const matches = text.matchAll(/\r\n|\r|\n|[ \t\v\f]+/g);
+  for (const match of matches) {
+    const start = baseOffset + match.index;
+    const end = start + match[0].length;
+    records.push(preservedParserSegment({
+      index: startIndex + records.length,
+      kind: /\r|\n/.test(match[0]) ? 'newline' : 'whitespace',
+      text: match[0],
+      start,
+      end,
+      sourceHash: options.sourceHash,
+      sourcePath: input.sourcePath,
+      sourceText: options.sourceText,
+      parserEvidence: options.parserEvidence,
+      parserKind: 'source-gap'
+    }));
+  }
+  return records;
+}
+
+function preservedParserSegment(input) {
+  const role = preservedSourceSegmentRole(input.kind);
+  const textHash = hashSemanticValue(input.text);
+  const span = {
+    sourceId: input.sourceHash,
+    path: input.sourcePath,
+    ...sourceSpanPositions(input.start, input.end, input.sourceText)
+  };
+  return {
+    id: `${input.kind}_${input.index + 1}_${idFragment(input.start)}`,
+    kind: input.kind,
+    role,
+    text: input.text,
+    textHash,
+    span,
+    ownershipAnchor: createPreservedSourceOwnershipAnchor({
+      kind: input.kind,
+      role,
+      text: input.text,
+      textHash,
+      sourcePath: input.sourcePath,
+      sourceHash: input.sourceHash,
+      span,
+      anchorKind: preservedOwnershipAnchorKind(input.kind, role),
+      parserEvidence: input.parserEvidence,
+      parserTriviaEvidence: {
+        status: 'exact',
+        exactParserTrivia: true,
+        losslessCst: true,
+        sourceHash: input.sourceHash,
+        parserEvidence: input.parserEvidence,
+        adapterId: 'syntax-ast'
+      }
+    }),
+    metadata: { parserKind: input.parserKind, parserEvidence: input.parserEvidence }
+  };
+}
+
+function parserSegmentsCoverSource(segments, sourceText) {
+  let cursor = 0;
+  for (const segment of segments) {
+    if (segment.span.start < cursor) return false;
+    if (!/^[\s]*$/.test(sourceText.slice(cursor, segment.span.start))) return false;
+    cursor = segment.span.end;
+  }
+  return /^[\s]*$/.test(sourceText.slice(cursor));
+}
+
+function sourceSpanPositions(start, end, sourceText) {
+  const beforeStart = String(sourceText ?? '').slice(0, start);
+  const beforeEnd = String(sourceText ?? '').slice(0, end);
+  const startLine = lineCount(beforeStart);
+  const endLine = lineCount(beforeEnd);
+  return {
+    start,
+    end,
+    startLine,
+    startColumn: start - lastLineStart(beforeStart) + 1,
+    endLine,
+    endColumn: end - lastLineStart(beforeEnd) + 1
+  };
+}
+
+function sourceRange(entry) {
+  if (Number.isFinite(entry?.start) && Number.isFinite(entry?.end)) return { start: entry.start, end: entry.end };
+  if (Array.isArray(entry?.range) && Number.isFinite(entry.range[0]) && Number.isFinite(entry.range[1])) {
+    return { start: entry.range[0], end: entry.range[1] };
+  }
+  return undefined;
+}
+
+function parserEntryKind(entry) {
+  const type = entry?.type;
+  if (typeof type === 'string') return type;
+  return type?.label ?? type?.keyword ?? type?.name ?? entry?.kind ?? 'Token';
+}
+
+function parserEntrySourceTextMatches(entry, text) {
+  const expected = entry?.raw ?? entry?.extra?.raw ?? entry?.text ?? entry?.source;
+  return typeof expected === 'string' ? expected === text : true;
+}
+
+function entryIsComment(entry, text) {
+  const kind = String(parserEntryKind(entry));
+  return kind.includes('Comment') || text.startsWith('//') || text.startsWith('/*');
+}
+
+function syntaxTokenKind(parserKind, text, sourcePath) {
+  const kind = String(parserKind);
+  if (kind === 'Identifier' || kind === 'name') return 'identifier';
+  if (kind === 'Keyword' || kind.endsWith('Keyword')) return 'keyword';
+  if (kind === 'String' || kind === 'StringLiteral' || kind === 'string') return 'string';
+  if (kind === 'Numeric' || kind === 'NumericLiteral' || kind === 'num') return 'number';
+  if (kind === 'RegularExpression' || kind === 'regexp') return 'regex-like';
+  if (kind.includes('Template') || text.startsWith('`')) return 'template';
+  if (kind.includes('JSX') || /\.(?:jsx|tsx)$/i.test(String(sourcePath ?? '')) && /^(?:<|<\/|\/>|>)$/.test(text)) return 'jsx';
+  if (/^[()[\]{};,]$/.test(text)) return 'punctuation';
+  if (/^[=+\-*/%&|^!<>?:.]+$/.test(text)) return 'operator';
+  return 'unknown';
+}
+
+function preservedCommentKind(text) {
+  const value = String(text ?? '');
+  if (/[#@]\s*sourceMappingURL=|[#@]\s*sourceURL=/.test(value)) return 'source-map-comment';
+  if (value.startsWith('/**') && value[3] !== '/') return 'jsdoc-comment';
+  if (value.startsWith('/*')) return 'block-comment';
+  return 'comment';
+}
+
+function limitRecords(records, maxValue) {
+  const max = Number.isFinite(maxValue) ? Math.max(0, maxValue) : 20000;
+  return { records: records.slice(0, max), truncated: records.length > max };
+}
+
+function uniqueParserEntries(entries) {
+  const seen = new Set();
+  return entries.filter((entry) => {
+    const range = sourceRange(entry);
+    if (!range) return false;
+    const key = `${range.start}:${range.end}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function arrayValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function lineCount(text) {
+  return text.split(/\r\n|\r|\n/).length;
+}
+
+function lastLineStart(text) {
+  return Math.max(text.lastIndexOf('\n') + 1, text.lastIndexOf('\r') + 1, 0);
+}