@pacem/pacem-foundation 1.0.6-ricci → 2.0.0-abel

package/dist/esm/array-extensions.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/arrays.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/blobs.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/browser.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/colors.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/dates.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/deepmerger.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/geom.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/history-svc.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/imaging.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/index-compile-markdown.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/index-compile.js

@@ -1,8 +1,13 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */
 import * as Markdown from './index-compile-markdown';
 export { Markdown };
 export * from './compile/parser';
+export * from './compile/syntax/types';
+export * from './compile/syntax/registry';
+export * from './compile/syntax/scanner';
+export * from './compile/syntax/highlight';
+export * from './compile/syntax/builtins';

package/dist/esm/index-iife.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/index-root.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/index.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/keygenerator.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/matrix2d.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/null-checker.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/number-extensions.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/numbers.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/rect.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/dist/esm/strings.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-foundation v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-foundation v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */

package/package.json

@@ -25,7 +25,7 @@
       "types": "./typings/index.d.ts"
     }
   },
-  "version": "1.0.6-ricci",
+  "version": "2.0.0-abel",
   "author": {
     "name": "Pacem",
     "url": "https://pacem.it"

package/typings/index.d.ts

@@ -101,6 +101,12 @@ export declare class Blobs {
 /** Text encodings supported by {@link Blobs.textToBlob}. */
 declare type BlobTextEncoding = 'utf-8' | 'utf-16' | 'utf-16be' | 'utf-16le' | 'iso-8859-1' | 'ascii';
 
+/** A {@link Syntax} shipped with foundation: its name, and its base syntax if any, are {@link SyntaxName}s. */
+declare interface BuiltinSyntax extends Syntax {
+    name: SyntaxName;
+    extends?: SyntaxName;
+}
+
 /** Represents a color in the CIE 1931 XYZ color space. */
 export declare interface CieXYZ {
     readonly x: number;
@@ -207,7 +213,28 @@ declare namespace Compile {
         Token,
         Lexer,
         Renderer,
-        Parser
+        Parser,
+        LexicalMatchRule,
+        LexicalIncludeRule,
+        LexicalRule,
+        LexicalCondition,
+        LexicalSyntax,
+        SyntaxName,
+        SyntaxNameOrAlias,
+        Syntax,
+        BuiltinSyntax,
+        SyntaxToken,
+        SyntaxTokenType,
+        Syntaxes,
+        Scanner,
+        DefaultHighlightClasses,
+        HighlightRenderer,
+        JavaScriptSyntax,
+        PacemBindingSyntax,
+        MarkupSyntax,
+        CSharpSyntax,
+        CSyntax,
+        JsonSyntax
     }
 }
 export { Compile }
@@ -222,6 +249,20 @@ declare namespace Compile_2 {
     }
 }
 
+/**
+ * C# vocabulary: XML doc comments (`doc-comment`), comments, preprocessor directives, strings (regular, verbatim, raw,
+ * interpolated with nested `{…}` expressions), chars, numbers (with suffixes), identifiers (`@verbatim` included),
+ * keywords (contextual ones included, not after `.`/`?.`), brackets, punctuation and operators.
+ */
+declare const CSharpSyntax: BuiltinSyntax;
+
+/**
+ * C/C++ vocabulary: comments (`/** … *\/` and `///` as `doc-comment`), preprocessor directives (with their `<header>`),
+ * strings (raw `R"x(…)x"` and prefixed ones included), chars, numbers (with suffixes/separators), identifiers, keywords
+ * (C and C++), brackets, punctuation and operators.
+ */
+declare const CSyntax: BuiltinSyntax;
+
 /** Date parsing and arithmetic utilities. */
 export declare class Dates {
     /**
@@ -291,6 +332,9 @@ export declare class DeepMerger {
     static merge<S extends PlainObject, T extends PlainObject>(source: S, target?: T): T & S;
 }
 
+/** Default token type → CSS class mapping, matching the `code-*` classes styled by the theme (see `ui/markdown.css`). */
+declare const DefaultHighlightClasses: Readonly<Record<string, string>>;
+
 /**
  * Detects the browser name and version from a user-agent string.
  * @param userAgent User-agent string to parse (defaults to `navigator.userAgent`).
@@ -329,6 +373,20 @@ declare type ExtraRule = (Compile_2.Rule | {
     lang: string;
 });
 
+/**
+ * Renders a token stream (typically produced by the {@link Scanner}) as HTML: every token's `raw` text is HTML-encoded and,
+ * when its type has a mapped class, wrapped in a `<span class="…">`.
+ */
+declare class HighlightRenderer implements Renderer {
+    private readonly _classes;
+    /**
+     * @param _classes Token type → CSS class mapping (defaults to {@link DefaultHighlightClasses}).
+     */
+    constructor(_classes?: Readonly<Record<string, string>>);
+    render(tree: Token[]): string;
+    private _renderToken;
+}
+
 /** Grants undo/redo functionalities for given state. */
 export declare class HistoryService<TState = any> {
     #private;
@@ -406,6 +464,20 @@ export declare type ImagingResizeOptions = {
     background?: string;
 };
 
+/**
+ * JavaScript vocabulary, TypeScript superset: comments (JSDoc as `doc-comment`), strings, template literals with nested
+ * `${…}` expressions, regular expression literals (told from divisions by the previous significant token), numbers
+ * (hex/binary/octal/BigInt/separators), identifiers (`#private` included), keywords (JS + TS, not after `.`/`?.`),
+ * brackets, punctuation and operators.
+ */
+declare const JavaScriptSyntax: BuiltinSyntax;
+
+/**
+ * JSON vocabulary (JSONC and JSON5-ish tolerant: comments, single quotes and trailing commas are recognized):
+ * object keys are `attribute`s, values `string`/`number`/`keyword` (`true`, `false`, `null`).
+ */
+declare const JsonSyntax: BuiltinSyntax;
+
 /** Unique key/id generation utilities. */
 export declare class Keys {
     #private;
@@ -438,6 +510,71 @@ declare interface Lexer {
     tokenize(input: string, grammar: Rule[]): Token[];
 }
 
+/** Predicate on the previous significant token, e.g. to tell a JavaScript regular expression literal from a division. */
+declare interface LexicalCondition {
+    /** The previous token must have one of these types. */
+    previousTypes?: string[];
+    /** The previous token must not have any of these types. */
+    previousNotTypes?: string[];
+    /** The previous token's raw text must be one of these. */
+    previousTexts?: string[];
+    /** The previous token's raw text must not be any of these. */
+    previousNotTexts?: string[];
+}
+
+/** Includes (at compile time) the rules of another state of the same syntax, in place. */
+declare interface LexicalIncludeRule {
+    include: string;
+}
+
+/**
+ * A lexical rule of a {@link Syntax} state: a regular expression (source string, compiled *sticky*) recognizing a token
+ * at the current position, plus the state transitions to apply once matched.
+ * Transitions are applied in this order: `pop`, `next`, `push`, `embed`.
+ */
+declare interface LexicalMatchRule {
+    /** Regular expression source (no delimiters), matched at the current position. */
+    match: string;
+    /** Extra regular expression flags (e.g. `'i'`); the sticky flag is implied. */
+    flags?: string;
+    /**
+     * Type of the produced token or, when an array, one type per capture group (groups are expected to cover the
+     * whole match: uncovered characters become `text` tokens).
+     */
+    type: string | string[];
+    /** Condition on the previous *significant* token (see {@link LexicalSyntax.insignificant}) for the rule to apply. */
+    when?: LexicalCondition;
+    /** Pops the current state (`true` = 1, or the number of states to pop). */
+    pop?: boolean | number;
+    /** Replaces the current state. */
+    next?: string;
+    /** Pushes a state of the same syntax. */
+    push?: string;
+    /** Pushes the start state of another (registered) syntax. */
+    embed?: SyntaxNameOrAlias;
+    /** With `embed`: regular expression source that, as soon as it matches, pops the embedded syntax (without consuming input). */
+    until?: string;
+}
+
+/** A rule of a {@link LexicalSyntax} state. */
+declare type LexicalRule = LexicalMatchRule | LexicalIncludeRule;
+
+/** Lexical part of a {@link Syntax}: a state machine of ordered rules, Monarch/TextMate-like. */
+declare interface LexicalSyntax {
+    /** Initial state (defaults to `'root'`). */
+    start?: string;
+    /** Ordered rules per state: the first rule matching at the current position wins. */
+    states: Record<string, LexicalRule[]>;
+    /** Keyword lists, by token type: tokens of a {@link keywordSources} type whose text is listed get that type instead. */
+    keywords?: Record<string, string[]>;
+    /** Token types keywords are looked up for (defaults to `['identifier']`). */
+    keywordSources?: string[];
+    /** Previous significant token texts preventing the keyword lookup (e.g. `'.'`, so that `obj.type` stays an identifier). */
+    keywordExceptAfter?: string[];
+    /** Token types ignored when evaluating {@link LexicalCondition}s (defaults to spaces, newlines and comments). */
+    insignificant?: string[];
+}
+
 declare namespace Markdown {
     export {
         ExtraRule,
@@ -445,6 +582,12 @@ declare namespace Markdown {
     }
 }
 
+/**
+ * Markup (HTML/XML) vocabulary: comments, doctypes/CDATA, tags (`tag`/`tagname`), attributes, quoted values (Pacem
+ * `{{ … }}` bindings tokenized with `pacem-binding`), entities, text, and `<script>` bodies tokenized with `javascript`.
+ */
+declare const MarkupSyntax: BuiltinSyntax;
+
 /** Represents the typical matrix for 2D graphics (css, svg, ...) */
 export declare interface Matrix2D {
     readonly a: number;
@@ -581,6 +724,18 @@ export declare class Numbers {
     static rebase(v: number | string, from: number, to: number): string;
 }
 
+/**
+ * Pacem binding-expression vocabulary (the content of `{{ … }}` attributes): JavaScript plus the special tokens
+ * resolved by core's `Expression`:
+ * - `binding-host`: `:host` (followed by `.`);
+ * - `binding-host-property`: `::name`;
+ * - `binding-item`: `^item`, `^^item`, … (repeater item, n levels up);
+ * - `binding-index`: `^index`, `^^index`, …;
+ * - `binding-element`: `#id` (element reference);
+ * - `binding-this`: `$this` / `this` (the bound element).
+ */
+declare const PacemBindingSyntax: BuiltinSyntax;
+
 /**
  * Extracts all the floating point numbers found in a string (e.g. `"10px 20px"` => `[10, 20]`).
  * @param input String to parse.
@@ -753,6 +908,22 @@ declare interface Rule {
     exec: (input: string, lexer?: Lexer) => Token[];
 }
 
+/**
+ * Language-agnostic lexical engine: tokenizes a source text according to a {@link Syntax} vocabulary.
+ * - lossless: concatenating the tokens' `raw` reproduces the source exactly;
+ * - linear: a single cursor and sticky regular expressions (compiled once per syntax);
+ * - error tolerant: unrecognized characters become `text` tokens, it never throws.
+ */
+declare class Scanner {
+    /**
+     * Tokenizes `source`.
+     * @param source Source text.
+     * @param syntax A {@link Syntax} or the name/alias of a registered one (see {@link Syntaxes}); an unknown one yields a single `text` token.
+     * @returns The lossless, positioned token stream.
+     */
+    tokenize(source: string, syntax: Syntax | SyntaxNameOrAlias): SyntaxToken[];
+}
+
 /** Represents a 2D size (width/height). */
 export declare interface Size {
     width: number;
@@ -805,6 +976,90 @@ export declare class Strings {
     static hash(input: string, algo?: HashAlgorithmIdentifier): Promise<string>;
 }
 
+/**
+ * A language vocabulary: everything the language-agnostic {@link Scanner} needs to tokenize a source text.
+ * It is plain, JSON-serializable data (regular expressions are strings), so vocabularies can be shipped or fetched as data
+ * and registered at runtime (see {@link Syntaxes}).
+ */
+declare interface Syntax {
+    /** Unique (case-insensitive) name, e.g. `'javascript'`. */
+    name: string;
+    /** Alternative names, e.g. `['js', 'ts', 'typescript']`. */
+    aliases?: string[];
+    /**
+     * Name of a base syntax: states are merged (this syntax's rules come first), keywords are merged too, and `include`s
+     * are resolved against the merged states.
+     */
+    extends?: SyntaxNameOrAlias;
+    lexical: LexicalSyntax;
+}
+
+/**
+ * Registry of the {@link Syntax} vocabularies known to the {@link Scanner}, by (case-insensitive) name and aliases.
+ * The built-in vocabularies (see {@link SyntaxName}) are registered upfront; more can be
+ * registered at runtime, e.g. after fetching them as JSON.
+ */
+declare class Syntaxes {
+    /**
+     * Registers (or replaces) a syntax under its name and aliases.
+     * @param syntax The vocabulary to register.
+     */
+    static register(syntax: Syntax): void;
+    /**
+     * Gets a registered syntax by name or alias.
+     * @param nameOrAlias Case-insensitive name or alias (e.g. `'ts'`).
+     * @returns The syntax, or `null` when unknown.
+     */
+    static get(nameOrAlias: SyntaxNameOrAlias): Syntax | null;
+    /** Names (and aliases) of every registered syntax. */
+    static names(): string[];
+}
+
+/** Names of the built-in vocabularies, registered as soon as the compile module loads (see {@link Syntaxes}). */
+declare type SyntaxName = 'javascript' | 'pacem-binding' | 'markup' | 'csharp' | 'c' | 'json';
+
+/**
+ * Name or alias of a registered syntax: a built-in {@link SyntaxName} (autocompleted), or any other name/alias
+ * registered at runtime (`string & {}` keeps the literals from collapsing into `string`).
+ */
+declare type SyntaxNameOrAlias = SyntaxName | (string & {});
+
+/** A {@link Token} produced by the {@link Scanner}: lossless (`raw` is the exact source slice) and positioned. */
+declare interface SyntaxToken extends Token {
+    /** Character offset in the source. */
+    readonly index: number;
+    /** 1-based line. */
+    readonly line: number;
+    /** 1-based column. */
+    readonly column: number;
+    /** Nesting depth of the lexical state stack (0 = start state of the outermost syntax). */
+    readonly depth: number;
+    /** Name of the syntax that produced the token (differs from the outermost one inside embedded syntaxes). */
+    readonly syntax: SyntaxNameOrAlias;
+}
+
+/** Token types shared by the built-in vocabularies (vocabularies may add their own). */
+declare enum SyntaxTokenType {
+    Text = "text",
+    Space = "space",
+    Newline = "newline",
+    Comment = "comment",
+    DocComment = "doc-comment",
+    Keyword = "keyword",
+    Identifier = "identifier",
+    String = "string",
+    Regex = "regex",
+    Number = "number",
+    Bracket = "bracket",
+    Punctuation = "punctuation",
+    Operator = "operator",
+    Preprocessor = "preprocessor",
+    Tag = "tag",
+    TagName = "tagname",
+    Attribute = "attribute",
+    Entity = "entity"
+}
+
 /** A lexical token produced by tokenizing input against a grammar. */
 declare interface Token {
     /** Position (character offset) within the original input where this token starts, if known. */