@limaformat/lima 0.5.1 → 0.7.0

package/dist/core.js

@@ -1,5 +1,5 @@
 /**
- * Lima Core 1.0 parser — reference-unaware by construction (Appendix B:
+ * Lima Core 1.1 parser — reference-unaware by construction (Appendix B:
  * reference resolution is exclusively the concern of the optional
  * References extension). `($key)`/`(%key)`-shaped text is never
  * recognised or coerced here; it simply falls through as an ordinary
@@ -19,6 +19,7 @@
  * and mappings) — this file is the orchestrator that ties them together.
  */
 import { checkKeyLength, byteLength, DOCUMENT_SIZE_LIMIT, TOP_LEVEL_KEY_LIMIT, NESTING_DEPTH_LIMIT, } from './normalize.js';
+import { validateDocument } from './document.js';
 import { unescapeDQ, stripComment, stripCommentKeepEscapes, positionedBuilder, NO_SPAN_VALUE, parseSimpleScalarSpan, } from './scalars.js';
 import { isTrimWhitespace } from './chars.js';
 import { parseFlowOrScalarValue } from './flow.js';
@@ -26,6 +27,7 @@ import { parseBlockRange } from './block.js';
 import { buildBlockScalar } from './block-scalar.js';
 import { LimaError } from './errors.js';
 import { KeyCursor, scanKeys } from './scanner.js';
+import { checkRangeLines, isBlockScalarMarker } from './structure.js';
 export { NESTING_DEPTH_LIMIT, SCALAR_LENGTH_LIMIT } from './normalize.js';
 export { toPlainValue } from './scalars.js';
 /** Every Lima mapping result must be a prototype-free object (Core §11.1). */
@@ -77,7 +79,7 @@ const lineAt = (s, pos) => {
     return n;
 };
 /**
- * Parses Lima Core 1.0 syntax, generic over the output representation
+ * Parses Lima Core 1.1 syntax, generic over the output representation
  * (`builder` — see `builder.ts`): References needs the annotated
  * `PositionedValue` tree (`parseCoreWithPositions` below fixes `V` to
  * that), while `parseCore` fixes `V` to the public native shape directly,
@@ -186,6 +188,18 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
         }
         const firstNewline = inlineEnd ?? frontMatter.indexOf('\n', rawStart);
         const newlineInRange = firstNewline < nextStart;
+        // §6.1.5: `|` alone is a literal block scalar marker, with a body or without one (then its value is empty).
+        // The introducing key is at column 0; `buildBlockScalar` finds the scalar's own extent within the range (which
+        // runs to the next top-level key), so a dedented comment or dedented freetext before that key ends the scalar
+        // rather than being absorbed into it.
+        if (!isBlock && frontMatter.charCodeAt(rawStart) === 124) {
+            const markerEnd = newlineInRange && firstNewline >= 0 ? firstNewline : nextStart;
+            if (frontMatter.slice(rawStart, markerEnd).trim() === '|') {
+                const bodyLines = markerEnd < nextStart ? frontMatter.slice(markerEnd + 1, nextStart).split('\n') : [];
+                builder.setMapping(root, key, buildBlockScalar(bodyLines, 0, line, ctx, builder).value);
+                return;
+            }
+        }
         // Physical codepoint column of the value's first character in its
         // source line — the anchor for References 2.0 token positions (§2.4).
         // References 2.0 token positions (§2.4): only build the source anchor
@@ -232,31 +246,18 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
                 lineStart = j + 1;
             }
         }
-        {
-            if (lines.length === 0) {
-                builder.setMapping(root, key, builder.null(line));
-                return;
-            }
-            const line0Trimmed = lines[0].trim();
-            if (lines.length === 1 || line0Trimmed !== '|') {
-                const line0 = lines[0];
-                const hasHash = line0.includes('#');
-                const val = hasHash ? stripComment(line0) : line0;
-                const source = wantSource ? {
-                    raw: hasHash ? stripCommentKeepEscapes(line0) : line0,
-                    line, col: valueCol, tabAdjust: lineTabAdjust,
-                } : undefined;
-                builder.setMapping(root, key, parseFlowOrScalarValue(val, ctx, line, builder, source));
-                return;
-            }
-            // Multi-line string (`|` literal block scalar). The introducing key
-            // is at column 0 here; `buildBlockScalar` finds the scalar's own
-            // extent within the range (which runs to the next top-level key),
-            // so a dedented comment or dedented freetext before that key ends
-            // the scalar rather than being absorbed into it.
-            const bodyLines = raw.slice(raw.indexOf('\n') + 1).split('\n');
-            builder.setMapping(root, key, buildBlockScalar(bodyLines, 0, line, ctx, builder).value);
+        if (lines.length === 0) {
+            builder.setMapping(root, key, builder.null(line));
+            return;
         }
+        const line0 = lines[0];
+        const hasHash = line0.includes('#');
+        const val = hasHash ? stripComment(line0) : line0;
+        const source = wantSource ? {
+            raw: hasHash ? stripCommentKeepEscapes(line0) : line0,
+            line, col: valueCol, tabAdjust: lineTabAdjust,
+        } : undefined;
+        builder.setMapping(root, key, parseFlowOrScalarValue(val, ctx, line, builder, source));
     };
     // A recognised top-level entry needs at least one UTF-16 unit of key text,
     // `:`, and its terminating newline: three units. Consequently 129 entries
@@ -293,6 +294,9 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
     else {
         const matches = scanKeys(frontMatter);
         const keyCount = matches.length;
+        // Core 1.1: before the first key no line belongs to any structure (structure.ts)
+        if (strict)
+            checkRangeLines(frontMatter, 0, keyCount === 0 ? frontMatter.length : matches[0].matchStart, 1, 'none');
         if (keyCount === 0)
             return root;
         if (keyCount > TOP_LEVEL_KEY_LIMIT) {
@@ -305,8 +309,19 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
             const m = matches[i];
             const rawDQ = m.doubleQuotedRaw;
             const key = m.unquoted ?? m.singleQuoted ?? (rawDQ !== undefined ? unescapeDQ(rawDQ, strict, m.line) : undefined);
+            const nextStart = i + 1 < keyCount ? matches[i + 1].matchStart : frontMatter.length;
             if (key !== undefined)
-                parseEntry(key, m.line, m.rawStart, m.isBlock, m.inlineEnd, i + 1 < keyCount ? matches[i + 1].matchStart : frontMatter.length);
+                parseEntry(key, m.line, m.rawStart, m.isBlock, m.inlineEnd, nextStart);
+            // Core 1.1: the lines after the key's own line, up to the next key, belong to its block or to nothing
+            if (strict) {
+                const lineEnd = m.isBlock ? m.rawStart - 1 : (m.inlineEnd ?? frontMatter.indexOf('\n', m.rawStart));
+                // no line after the key's own one: nothing to check, the usual case
+                if (lineEnd !== -1 && lineEnd + 1 < nextStart) {
+                    const owner = m.isBlock ? 'mapping'
+                        : isBlockScalarMarker(frontMatter, m.rawStart, lineEnd) ? 'scalar' : 'inline';
+                    checkRangeLines(frontMatter, lineEnd + 1, nextStart, m.line + 1, owner, m.rawStart, lineEnd);
+                }
+            }
         }
     }
     // Core §9 nesting depth, over Core's own reference-inert tree. When
@@ -322,7 +337,7 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
     return root;
 };
 /**
- * Parses Lima Core 1.0 syntax into the internal annotated value tree —
+ * Parses Lima Core 1.1 syntax into the internal annotated value tree —
  * every node carrying its source line, string leaves additionally carrying
  * whether they came from quoted syntax. `($key)`/`(%key)` text is left
  * exactly as written; nothing here ever inspects or resolves it. The
@@ -438,13 +453,17 @@ export const toNativeFromPositioned = (v) => {
     }
 };
 /**
- * Public Core 1.0 entry point. Never resolves `($key)`/`(%key)` text — see
+ * Public Core 1.1 entry point. Never resolves `($key)`/`(%key)` text — see
  * the module doc comment. Equivalent in observable behavior to calling
  * `parseReferences()` with no partials on a document that happens to
  * contain no references, except that here reference-shaped text is
  * guaranteed to always pass through unresolved, even in strict mode.
  */
-export const parseCore = (frontMatter, options) => {
+export const parseCoreValidated = (frontMatter, options) => {
     const ctx = { strict: options?.strict ?? false, onWarning: options?.onWarning };
     return parseCoreGeneric(frontMatter, ctx, nativeBuilder, depthOfNative);
 };
+export const parseCore = (frontMatter, options) => {
+    validateDocument(frontMatter);
+    return parseCoreValidated(frontMatter, options);
+};

package/dist/document.d.ts

@@ -0,0 +1,2 @@
+/** Core §1: a document is a sequence of Unicode scalar values. */
+export declare const validateDocument: (document: string) => void;

package/dist/document.js

@@ -0,0 +1,29 @@
+import { LimaError } from './errors.js';
+/** Core §1: a document is a sequence of Unicode scalar values. */
+export const validateDocument = (document) => {
+    // Node 22's native scalar-value check keeps the common valid path out of
+    // JavaScript. Only malformed input pays for the line-attribution walk.
+    if (document.isWellFormed())
+        return;
+    let line = 1;
+    for (let i = 0; i < document.length; i++) {
+        const c = document.charCodeAt(i);
+        if (c === 10) {
+            line++;
+            continue;
+        }
+        if (c >= 0xd800 && c <= 0xdbff && i + 1 < document.length) {
+            const low = document.charCodeAt(i + 1);
+            if (low >= 0xdc00 && low <= 0xdfff) {
+                i++;
+                continue;
+            }
+        }
+        if (c >= 0xd800 && c <= 0xdfff) {
+            throw new LimaError({
+                code: 'INVALID_DOCUMENT', line,
+                message: `Lima: document contains an invalid Unicode scalar value at line ${line}`,
+            });
+        }
+    }
+};

package/dist/errors.d.ts

@@ -8,7 +8,7 @@
  * module directly rather than duplicating it) inspect *why* a parse failed
  * without re-parsing the message string.
  */
-export type LimaDiagnosticCode = 'INVALID_ESCAPE' | 'INVALID_QUOTE' | 'INVALID_DATE' | 'INVALID_NUMBER' | 'INVALID_REFERENCE_SHAPE' | 'INVALID_INDENTATION' | 'INVALID_FLOW_SYNTAX' | 'DUPLICATE_KEY' | 'RESOURCE_LIMIT' | 'UNRESOLVED_REFERENCE' | 'INVALID_INTERPOLATION' | 'INVALID_PARTIAL';
+export type LimaDiagnosticCode = 'INVALID_DOCUMENT' | 'INVALID_ESCAPE' | 'INVALID_QUOTE' | 'INVALID_DATE' | 'INVALID_NUMBER' | 'INVALID_REFERENCE_SHAPE' | 'INVALID_INDENTATION' | 'UNRECOGNIZED_LINE' | 'INVALID_FLOW_SYNTAX' | 'DUPLICATE_KEY' | 'RESOURCE_LIMIT' | 'UNRESOLVED_REFERENCE' | 'INVALID_INTERPOLATION' | 'INVALID_PARTIAL';
 export interface LimaDiagnostic {
     code: LimaDiagnosticCode;
     message: string;

package/dist/index.d.ts

@@ -3,12 +3,12 @@
  *
  * Public entry point. The implementation is split per Appendix B's own
  * layering:
- *   - `core.ts`       — Lima Core 1.0, reference-unaware by construction.
- *   - `references2.ts` — the References 2.0 extension layered on Core.
+ *   - `core.ts`       — Lima Core 1.2, reference-unaware by construction.
+ *   - `references2.ts` — the References 2.1 extension layered on Core.
  *   - `references.ts`  — the frozen internal References 1.0 implementation.
  *   - `value.ts`       — the shared Lima Value Model both build on.
  *
- * `parse` is the primary References 2.0 entry point. `parseReferences` is
+ * `parse` is the primary References 2.1 entry point. `parseReferences` is
  * retained as its deprecated compatibility alias.
  */
 export { parseCore, type CoreOptions, type Diagnostic } from './core.js';

package/dist/index.js

@@ -3,12 +3,12 @@
  *
  * Public entry point. The implementation is split per Appendix B's own
  * layering:
- *   - `core.ts`       — Lima Core 1.0, reference-unaware by construction.
- *   - `references2.ts` — the References 2.0 extension layered on Core.
+ *   - `core.ts`       — Lima Core 1.2, reference-unaware by construction.
+ *   - `references2.ts` — the References 2.1 extension layered on Core.
  *   - `references.ts`  — the frozen internal References 1.0 implementation.
  *   - `value.ts`       — the shared Lima Value Model both build on.
  *
- * `parse` is the primary References 2.0 entry point. `parseReferences` is
+ * `parse` is the primary References 2.1 entry point. `parseReferences` is
  * retained as its deprecated compatibility alias.
  */
 export { parseCore } from './core.js';

package/dist/key-grammar.d.ts

@@ -0,0 +1,3 @@
+export declare const isKeyInitialCodePoint: (c: number) => boolean;
+export declare const isKeyCharacterCodePoint: (c: number) => boolean;
+export declare const isValidUnquotedKey: (raw: string, allowSlash?: boolean) => boolean;

package/dist/key-grammar.js

@@ -0,0 +1,58 @@
+import { UNICODE_KEY_RANGES } from './unicode-key-table.js';
+const unicodeKeyCategory = (codePoint) => {
+    let low = 0;
+    let high = UNICODE_KEY_RANGES.length / 3;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        const offset = mid * 3;
+        if (codePoint < UNICODE_KEY_RANGES[offset])
+            high = mid;
+        else if (codePoint > UNICODE_KEY_RANGES[offset + 1])
+            low = mid + 1;
+        else
+            return UNICODE_KEY_RANGES[offset + 2];
+    }
+    return 0;
+};
+export const isKeyInitialCodePoint = (c) => {
+    if (c <= 0x7f)
+        return c === 95 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122;
+    return (unicodeKeyCategory(c) & 5) !== 0; // L or N
+};
+export const isKeyCharacterCodePoint = (c) => {
+    if (c <= 0x7f)
+        return isKeyInitialCodePoint(c) || c === 58 || c === 45 || c === 42;
+    return c === 0xb7 || unicodeKeyCategory(c) !== 0; // L, M or N
+};
+export const isValidUnquotedKey = (raw, allowSlash = false) => {
+    if (raw.length === 0)
+        return false;
+    let i = 0;
+    let cp = raw.charCodeAt(0);
+    if (cp <= 0x7f) {
+        if (!(cp === 95 || cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122))
+            return false;
+        i = 1;
+    }
+    else {
+        cp = raw.codePointAt(0);
+        if (!isKeyInitialCodePoint(cp))
+            return false;
+        i = cp > 0xffff ? 2 : 1;
+    }
+    while (i < raw.length) {
+        cp = raw.charCodeAt(i);
+        if (cp <= 0x7f) {
+            if (!(cp === 95 || cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 ||
+                cp === 58 || cp === 45 || cp === 42 || allowSlash && cp === 47))
+                return false;
+        }
+        else {
+            cp = raw.codePointAt(i);
+            if (!isKeyCharacterCodePoint(cp))
+                return false;
+        }
+        i += cp > 0xffff ? 2 : 1;
+    }
+    return true;
+};

package/dist/key-hints.d.ts

@@ -0,0 +1,2 @@
+export declare const KEY_GRAMMAR_HINT = " (an unquoted key starts with a Unicode letter or number or \"_\", then has letters, marks, numbers, \"_\", \":\", \"-\", \"*\" and \"\u00B7\"; quote any other)";
+export declare const specificKeyHint: (text: string) => string | undefined;

package/dist/key-hints.js

@@ -0,0 +1,17 @@
+import { isTrimWhitespace } from './chars.js';
+import { isValidUnquotedKey } from './key-grammar.js';
+export const KEY_GRAMMAR_HINT = ' (an unquoted key starts with a Unicode letter or number or "_", then has letters, marks, numbers, "_", ":", "-", "*" and "·"; quote any other)';
+export const specificKeyHint = (text) => {
+    let i = 0;
+    while (text.charCodeAt(i) === 32)
+        i++;
+    const cp = text.codePointAt(i);
+    if (cp !== undefined && cp !== 32 && isTrimWhitespace(cp)) {
+        return ` (U+${cp.toString(16).toUpperCase().padStart(4, '0')} before the key; Lima indents by spaces only)`;
+    }
+    const colon = text.indexOf('\uFF1A');
+    if (colon > 0 && isValidUnquotedKey(text.slice(0, colon))) {
+        return ' (the key-value separator is ": " (U+003A and a space), not U+FF1A FULLWIDTH COLON)';
+    }
+    return undefined;
+};

package/dist/reference-tokens2.d.ts

@@ -39,11 +39,6 @@ export type ReferenceSource = {
     col: number;
     tabAdjust?: number[];
 };
-export declare const SEGMENT = "[a-zA-Z0-9_][a-zA-Z0-9_:-]*";
-export declare const DOC_PATH = "[a-zA-Z0-9_][a-zA-Z0-9_:-]*(?:\\.[a-zA-Z0-9_][a-zA-Z0-9_:-]*)*";
-export declare const PARTIAL_NAME = "[a-zA-Z0-9_][a-zA-Z0-9_:/-]*";
-export declare const PARTIAL_PATH = "[a-zA-Z0-9_][a-zA-Z0-9_:/-]*(?:\\.[a-zA-Z0-9_][a-zA-Z0-9_:-]*)*";
-export declare const PURE_REFERENCE_2: RegExp;
 /** Converts a 0-based codepoint offset to JavaScript/LSP UTF-16 units. */
 export declare const codepointOffsetToUtf16: (text: string, codepointOffset: number) => number;
 /** Converts a 0-based JavaScript/LSP UTF-16 offset to a codepoint offset. */

package/dist/reference-tokens2.js

@@ -1,11 +1,8 @@
 /** Reference tokens recorded while the annotated Core tree is being built. */
-export const SEGMENT = '[a-zA-Z0-9_][a-zA-Z0-9_:-]*';
-export const DOC_PATH = `${SEGMENT}(?:\\.${SEGMENT})*`;
-export const PARTIAL_NAME = '[a-zA-Z0-9_][a-zA-Z0-9_:/-]*';
-export const PARTIAL_PATH = `${PARTIAL_NAME}(?:\\.${SEGMENT})*`;
-export const PURE_REFERENCE_2 = new RegExp(`^(?:\\$\\{(${DOC_PATH})\\}|\\$\\((${PARTIAL_PATH})\\))$`);
-const REFERENCE_2 = new RegExp(`\\$\\{(${DOC_PATH})\\}|\\$\\((${PARTIAL_PATH})\\)`, 'g');
+import { isKeyCharacterCodePoint, isKeyInitialCodePoint } from './key-grammar.js';
 const NO_TOKENS = [];
+const isAsciiReferenceInitial = (c) => (c >= 97 && c <= 122) || (c >= 65 && c <= 90) || (c >= 48 && c <= 57) || c === 95;
+const isAsciiReferenceCharacter = (c, allowSlash) => isAsciiReferenceInitial(c) || c === 58 || c === 45 || c === 42 || allowSlash && c === 47;
 const utf16WidthAt = (text, offset) => text.codePointAt(offset) > 0xffff ? 2 : 1;
 /** Codepoint length of the UTF-16 slice `[a, b)` of `s`. */
 const codepointLen = (s, a, b) => {
@@ -38,27 +35,80 @@ export const utf16OffsetToCodepoint = (text, utf16Offset) => {
     return codepoints;
 };
 /** Splice points (decoded value order): token text, UTF-16 index, path. */
+const scanComponent = (value, start, allowSlash) => {
+    let i = start;
+    if (i >= value.length)
+        return -1;
+    let cp = value.charCodeAt(i);
+    if (cp <= 0x7f) {
+        if (!isAsciiReferenceInitial(cp))
+            return -1;
+    }
+    else {
+        cp = value.codePointAt(i);
+        if (!isKeyInitialCodePoint(cp))
+            return -1;
+    }
+    i += cp > 0xffff ? 2 : 1;
+    while (i < value.length && isAsciiReferenceCharacter(value.charCodeAt(i), allowSlash))
+        i++;
+    while (i < value.length) {
+        cp = value.charCodeAt(i);
+        if (cp <= 0x7f)
+            break;
+        cp = value.codePointAt(i);
+        if (!isKeyCharacterCodePoint(cp))
+            break;
+        i += cp > 0xffff ? 2 : 1;
+        while (i < value.length && isAsciiReferenceCharacter(value.charCodeAt(i), allowSlash))
+            i++;
+    }
+    return i;
+};
+const scanPath = (value, start, partial) => {
+    let i = scanComponent(value, start, partial);
+    if (i < 0)
+        return -1;
+    while (value.charCodeAt(i) === 46) {
+        const next = scanComponent(value, i + 1, false);
+        if (next < 0)
+            return -1;
+        i = next;
+    }
+    return i;
+};
 const scanDecoded = (value) => {
-    REFERENCE_2.lastIndex = 0;
     const out = [];
-    for (const m of value.matchAll(REFERENCE_2)) {
-        out.push({
-            token: m[0], index: m.index ?? 0,
-            ...(m[1] !== undefined ? { documentPath: m[1] } : { partialPath: m[2] }),
-        });
+    for (let i = 0; i + 2 < value.length;) {
+        const partial = value.startsWith('$(', i);
+        const document = !partial && value.startsWith('${', i);
+        if (!partial && !document) {
+            const cp = value.codePointAt(i);
+            i += cp > 0xffff ? 2 : 1;
+            continue;
+        }
+        const end = scanPath(value, i + 2, partial);
+        const close = partial ? 41 : 125;
+        if (end >= 0 && value.charCodeAt(end) === close) {
+            const token = value.slice(i, end + 1);
+            const path = value.slice(i + 2, end);
+            out.push({ token, index: i, ...(partial ? { partialPath: path } : { documentPath: path }) });
+            i = end + 1;
+        }
+        else
+            i++;
     }
     return out;
 };
 /** Physical `(line, offset)` of each token, in source order, from the raw text. */
 const scanPhysical = (raw, firstLine, firstCol, tabAdjust) => {
-    REFERENCE_2.lastIndex = 0;
     const out = [];
     let scanned = 0;
     let line = firstLine;
     let col = firstCol;
     let lineIndex = 0;
-    for (const m of raw.matchAll(REFERENCE_2)) {
-        const idx = m.index ?? 0;
+    for (const m of scanDecoded(raw)) {
+        const idx = m.index;
         while (scanned < idx) {
             const cp = raw.codePointAt(scanned);
             if (cp === 10) {

package/dist/references2.js

@@ -1,11 +1,11 @@
-/** Lima References 2.0 resolver. References 1.0 remains isolated in references.ts. */
+/** Lima References 2.1 resolver. References 1.0 remains isolated in references.ts. */
 import { canonicalString, codepointLength, countNodes, ingestPartialValue, PARTIAL_COUNT_LIMIT, PARTIAL_NAME_LENGTH_LIMIT, PARTIAL_NODE_LIMIT, RESULT_NODE_LIMIT, SCALAR_LENGTH_LIMIT, } from './value.js';
-import { NESTING_DEPTH_LIMIT, parseCore, parseCoreWithPositions, toPlainValue, } from './core.js';
+import { isValidUnquotedKey } from './key-grammar.js';
+import { validateDocument } from './document.js';
+import { NESTING_DEPTH_LIMIT, parseCoreValidated, parseCoreWithPositions, toPlainValue, } from './core.js';
 import { hasActiveReferences2 } from './scalars.js';
 import { LimaError } from './errors.js';
 import { collectAllParticipants, deepCopyPositioned, earliestParticipant, emptyMapping, finalizePositioned, partialToPositioned, } from './positioned-tree.js';
-const PARTIAL_NAME = '[a-zA-Z0-9_][a-zA-Z0-9_:/-]*';
-const PARTIAL_NAME_RE = new RegExp(`^${PARTIAL_NAME}$`);
 const MAX_EDGES = 3;
 // Looking up the root path is itself the first reference edge; recursion into
 // that root therefore gets the public resolver's remaining two-edge budget.
@@ -317,7 +317,7 @@ const validatePartials = (raw) => {
         throw new LimaError({ code: 'INVALID_PARTIAL', message: `Lima: too many partials (max ${PARTIAL_COUNT_LIMIT})` });
     }
     for (const name of names) {
-        if (!PARTIAL_NAME_RE.test(name)) {
+        if (!isValidUnquotedKey(name, true)) {
             throw new LimaError({ code: 'INVALID_PARTIAL', partial: name, message: `Lima: invalid partial name "${name}"` });
         }
         if (codepointLength(name) > PARTIAL_NAME_LENGTH_LIMIT) {
@@ -356,6 +356,7 @@ const scanUnresolved = (node, ctx) => {
             scanUnresolved(child, ctx);
 };
 const parseInternal = (frontMatter, options, useResolveCache) => {
+    validateDocument(frontMatter);
     if (options?.mode !== undefined && options.mode !== 'core' && options.mode !== 'references') {
         throw new TypeError(`Lima: invalid parse mode "${String(options.mode)}"`);
     }
@@ -365,11 +366,11 @@ const parseInternal = (frontMatter, options, useResolveCache) => {
         }
         // Core ignores the additional `mode` property. Passing the same object
         // avoids allocating a projected options object on this hot dispatch path.
-        return parseCore(frontMatter, options);
+        return parseCoreValidated(frontMatter, options);
     }
     const partials = validatePartials(options?.partials ?? {});
     if (!frontMatter.includes('${') && !frontMatter.includes('$(')) {
-        return parseCore(frontMatter, options);
+        return parseCoreValidated(frontMatter, options);
     }
     const document = parseCoreWithPositions(frontMatter, { strict: options?.strict ?? false, onWarning: options?.onWarning });
     const ctx = { diagnostics: [], ...(useResolveCache ? { cache: new WeakMap() } : {}) };

package/dist/scalars.js

@@ -354,8 +354,9 @@ export const closingQuoteIndex = (s, singleQuoteEscape = true) => {
  * Kept byte-for-byte identical to `scanner.ts`'s `isKeyStartChar` /
  * `isKeyContinueChar`, which enforce the same grammar at the top level.
  */
-const isUnquotedKeyStart = (c) => (c >= 97 && c <= 122) || (c >= 65 && c <= 90) || (c >= 48 && c <= 57) || c === 95;
-const isUnquotedKeyContinue = (c) => isUnquotedKeyStart(c) || c === 58 || c === 45;
+import { isValidUnquotedKey } from './key-grammar.js';
+const isAsciiUnquotedKeyStart = (c) => (c >= 97 && c <= 122) || (c >= 65 && c <= 90) || (c >= 48 && c <= 57) || c === 95;
+const isAsciiUnquotedKeyContinue = (c) => isAsciiUnquotedKeyStart(c) || c === 58 || c === 45 || c === 42;
 /**
  * Whether `raw` (a key candidate as written, before quote stripping) is a
  * usable Lima key:
@@ -375,13 +376,17 @@ export const isValidKey = (raw) => {
     const f = raw.charCodeAt(0);
     if (f === 34 || f === 39)
         return closingQuoteIndex(raw, false) === raw.length - 1;
-    if (!isUnquotedKeyStart(f))
-        return false;
-    for (let i = 1; i < raw.length; i++) {
-        if (!isUnquotedKeyContinue(raw.charCodeAt(i)))
+    if (f <= 0x7f) {
+        if (!isAsciiUnquotedKeyStart(f))
             return false;
+        for (let i = 1; i < raw.length; i++) {
+            const c = raw.charCodeAt(i);
+            if (!isAsciiUnquotedKeyContinue(c))
+                return c > 0x7f && isValidUnquotedKey(raw);
+        }
+        return true;
     }
-    return true;
+    return isValidUnquotedKey(raw);
 };
 const ANY_ESCAPE_RE = /\\(u[0-9a-fA-F]{0,4}|U[0-9a-fA-F]{0,8}|x[0-9a-fA-F]{0,2}|.)/gs;
 const SINGLE_CHAR_ESCAPES = '"\\/bfnrt'; // deliberately excludes '0' — Core Appendix A: \0 is unknown, not a null shorthand.

package/dist/scanner.js

@@ -50,8 +50,9 @@
  *     U+2028 / U+2029 included, is consumed as an escape pair here and
  *     resolved at decode time.
  */
-const isKeyStartChar = (c) => (c >= 97 && c <= 122) || (c >= 65 && c <= 90) || (c >= 48 && c <= 57) || c === 95; // a-z A-Z 0-9 _
-const isKeyContinueChar = (c) => isKeyStartChar(c) || c === 58 || c === 45; // + : -
+import { isKeyCharacterCodePoint, isKeyInitialCodePoint } from './key-grammar.js';
+const isAsciiKeyStart = (c) => (c >= 97 && c <= 122) || (c >= 65 && c <= 90) || (c >= 48 && c <= 57) || c === 95;
+const isAsciiKeyContinue = (c) => isAsciiKeyStart(c) || c === 58 || c === 45 || c === 42;
 /** Positive = block end, negative = inline end, zero = no separator. */
 const matchSeparator = (s, pos) => {
     let i = pos;
@@ -59,6 +60,10 @@ const matchSeparator = (s, pos) => {
         i++; // consume spaces
     if (i < s.length && s.charCodeAt(i) === 10)
         return i + 1;
+    // Core 1.1: the end of the input ends the key's line as a newline does, so a last `key:` is `key: null`, as it
+    // is at any nested level (it was no key at all at the top level before)
+    if (i === s.length)
+        return i;
     // Backtracking a pure-space run can never reveal a `\n` the maximal
     // scan didn't already see (every intermediate position is followed by
     // either another space or the same non-`\n` stop character) — so
@@ -121,11 +126,30 @@ const matchAt = (s, pos, line, out) => {
         keyKind = 2;
     }
     else {
-        if (!isKeyStartChar(c))
+        if (c <= 0x7f && !isAsciiKeyStart(c))
             return false;
         let runEnd = pos + 1;
-        while (runEnd < s.length && isKeyContinueChar(s.charCodeAt(runEnd)))
+        if (c > 0x7f) {
+            const first = s.codePointAt(pos);
+            if (!isKeyInitialCodePoint(first))
+                return false;
+            runEnd = pos + (first > 0xffff ? 2 : 1);
+        }
+        // Preserve the old tiny ASCII loop. Unicode decoding is entered only
+        // when this key actually reaches a non-ASCII code unit.
+        while (runEnd < s.length && isAsciiKeyContinue(s.charCodeAt(runEnd)))
             runEnd++;
+        while (runEnd < s.length) {
+            let cp = s.charCodeAt(runEnd);
+            if (cp <= 0x7f)
+                break;
+            cp = s.codePointAt(runEnd);
+            if (!isKeyCharacterCodePoint(cp))
+                break;
+            runEnd += cp > 0xffff ? 2 : 1;
+            while (runEnd < s.length && isAsciiKeyContinue(s.charCodeAt(runEnd)))
+                runEnd++;
+        }
         for (let k = runEnd - 1; k >= pos + 1; k--) {
             if (s.charCodeAt(k) !== 58)
                 continue;

package/dist/structure.d.ts

@@ -0,0 +1,13 @@
+/**
+ * What the lines after a key belong to: nothing (`none`, before the first key; `inline`, after an inline value), a
+ * block mapping or sequence (`mapping`, after a bare key) or a `|` scalar (`scalar`).
+ */
+export type RangeOwner = 'none' | 'inline' | 'mapping' | 'scalar';
+/**
+ * Checks the lines of `frontMatter` from `start` (a line start) to `end` that follow a key owned as `owner`; `line`
+ * is the 1-based line at `start`; `valueStart` to `valueEnd` is the inline value of that key, read only for the hint a
+ * YAML marker earns in the error. Throws for the first line that belongs to no structure.
+ */
+export declare function checkRangeLines(frontMatter: string, start: number, end: number, line: number, owner: RangeOwner, valueStart?: number, valueEnd?: number): void;
+/** Whether the inline value that starts at `rawStart` and ends its line at `lineEnd` is a `|` block scalar marker. */
+export declare const isBlockScalarMarker: (frontMatter: string, rawStart: number, lineEnd: number) => boolean;