grammar-well 1.1.2 → 1.1.4

package/build/typings.d.ts

@@ -1,198 +1,199 @@
-import { TokenBuffer } from "./lexers/token-buffer";
-import { ParserUtility } from "./parser/parser";
-export interface Dictionary<T> {
-    [key: string]: T;
-}
-export interface CompileOptions {
-    version?: string;
-    noscript?: boolean;
-    basedir?: string;
-    resolver?: ImportResolverConstructor;
-    resolverInstance?: ImportResolver;
-    exportName?: string;
-    template?: TemplateFormat;
-}
-export type TemplateFormat = '_default' | 'object' | 'json' | 'js' | 'javascript' | 'module' | 'esmodule' | 'esm' | 'ts' | 'typescript';
-export interface GrammarBuilderContext {
-    alreadyCompiled: Set<string>;
-    resolver: ImportResolver;
-    uuids: Dictionary<number>;
-}
-export interface ImportResolver {
-    path(path: string): string;
-    body(path: string): Promise<string>;
-}
-export interface ImportResolverConstructor {
-    new (basePath: string): ImportResolver;
-}
-export type PostProcessor = (payload: PostProcessorPayload) => any;
-interface PostProcessorPayload {
-    data: any[];
-    rule: GrammarRule;
-    meta: any;
-}
-export type JavascriptDirective = {
-    body: GrammarTypeJS;
-} | {
-    head: GrammarTypeJS;
-};
-export interface ImportDirective {
-    import: string;
-    path?: boolean;
-}
-export interface ConfigDirective {
-    config: Dictionary<any>;
-}
-export interface GrammarDirective {
-    grammar: {
-        config?: Dictionary<any>;
-        rules: GrammarBuilderRule[];
-    };
-}
-export interface LexerDirective {
-    lexer: {
-        start?: string;
-        states: LexerStateDefinition[];
-    };
-}
-export interface GrammarBuilderRule {
-    name: string;
-    expressions: GrammarBuilderExpression[];
-    postprocess?: GrammarTypeJS | GrammarTypeBuiltIn | GrammarTypeTemplate;
-}
-export interface GrammarBuilderExpression {
-    symbols: GrammarBuilderSymbol[];
-    postprocess?: GrammarTypeJS | GrammarTypeBuiltIn | GrammarTypeTemplate;
-}
-export type GrammarBuilderSymbol = GrammarTypeRule | GrammarTypeRegex | GrammarTypeToken | GrammarTypeLiteral | GrammarBuilderSymbolRepeat | GrammarBuilderSymbolSubexpression;
-export interface GrammarBuilderSymbolSubexpression {
-    subexpression: GrammarBuilderExpression[];
-}
-export interface GrammarBuilderSymbolRepeat {
-    expression: GrammarBuilderSymbol;
-    repeat: "+" | "*" | "?";
-}
-export interface GrammarTypeRule {
-    rule: string;
-}
-export interface GrammarTypeRegex {
-    regex: string;
-    flags?: string;
-}
-export interface GrammarTypeToken {
-    token: string;
-}
-export interface GrammarTypeLiteral {
-    literal: string;
-    insensitive?: boolean;
-}
-export type GrammarTypeBuiltIn = {
-    builtin: string;
-};
-export type GrammarTypeTemplate = {
-    template: string;
-};
-export type GrammarTypeJS = {
-    js: string;
-};
-export type ParserAlgorithm = ((language: LanguageDefinition & {
-    tokens: TokenBuffer;
-    utility: ParserUtility;
-}, options?: any) => {
-    results: any[];
-    info?: any;
-});
-export type LanguageDirective = (JavascriptDirective | ImportDirective | ConfigDirective | GrammarDirective | LexerDirective);
-type GrammarRuleSymbolFunction = (data: LexerToken) => boolean;
-export interface GrammarRule {
-    name: string;
-    symbols: GrammarRuleSymbol[];
-    postprocess?: PostProcessor;
-}
-export type GrammarRuleSymbol = string | RegExp | GrammarTypeLiteral | GrammarTypeToken | GrammarRuleSymbolFunction;
-export interface GeneratorGrammarRule {
-    name: string;
-    symbols: GeneratorGrammarSymbol[];
-    postprocess?: GrammarTypeTemplate | GrammarTypeBuiltIn | GrammarTypeJS;
-}
-export type GeneratorGrammarSymbol = {
-    alias?: string;
-} & (GrammarTypeRule | GrammarTypeRegex | GrammarTypeLiteral | GrammarTypeToken | GrammarTypeJS);
-export interface LanguageDefinition {
-    lexer?: Lexer | LexerConfig;
-    grammar: {
-        start: string;
-        rules: Dictionary<GrammarRule[]>;
-    };
-}
-export interface TQRestorePoint {
-    historyIndex: number;
-    offset: number;
-}
-export interface Lexer {
-    next(): LexerToken | undefined;
-    feed(chunk?: string, state?: ReturnType<Lexer['state']>): void;
-    state(): any;
-    flush?(): void;
-}
-export interface LexerToken {
-    type?: string | undefined;
-    tag?: Set<string>;
-    value: string;
-    offset: number;
-    line: number;
-    column: number;
-}
-export interface LexerStatus {
-    index: number;
-    line: number;
-    column: number;
-    state: string;
-}
-export interface LexerStateDefinition {
-    name: string;
-    unmatched?: string;
-    default?: string;
-    rules: (LexerStateImportRule | LexerStateMatchRule)[];
-}
-export interface LexerStateImportRule {
-    import: string[];
-}
-export interface LexerStateMatchRule {
-    when: string | RegExp;
-    type?: string;
-    tag?: string[];
-    pop?: number | 'all';
-    inset?: number;
-    goto?: string;
-    set?: string;
-}
-export interface ResolvedStateDefinition {
-    name: string;
-    unmatched?: string;
-    rules: LexerStateMatchRule[];
-}
-export interface CompiledStateDefinition {
-    regexp: RegExp;
-    unmatched?: LexerStateMatchRule;
-    rules: LexerStateMatchRule[];
-}
-export interface LexerConfig {
-    start?: string;
-    states: Dictionary<LexerStateDefinition>;
-}
-export interface GeneratorState {
-    version: string;
-    config: Dictionary<string>;
-    head: string[];
-    body: string[];
-    lexer?: LexerConfig;
-    grammar: {
-        start: string;
-        rules: Dictionary<GeneratorGrammarRule[]>;
-        uuids: {
-            [key: string]: number;
-        };
-    };
-}
-export {};
+import { TokenBuffer } from "./lexers/token-buffer";
+import { ParserUtility } from "./parser/parser";
+export interface Dictionary<T> {
+    [key: string]: T;
+}
+export interface CompileOptions {
+    version?: string;
+    noscript?: boolean;
+    basedir?: string;
+    resolver?: ImportResolverConstructor;
+    resolverInstance?: ImportResolver;
+    exportName?: string;
+    template?: TemplateFormat;
+}
+export type TemplateFormat = '_default' | 'object' | 'json' | 'js' | 'javascript' | 'module' | 'esmodule' | 'esm' | 'ts' | 'typescript';
+export interface GrammarBuilderContext {
+    alreadyCompiled: Set<string>;
+    resolver: ImportResolver;
+    uuids: Dictionary<number>;
+}
+export interface ImportResolver {
+    path(path: string): string;
+    body(path: string): Promise<string>;
+}
+export interface ImportResolverConstructor {
+    new (basePath: string): ImportResolver;
+}
+export type PostProcessor = (payload: PostProcessorPayload) => any;
+interface PostProcessorPayload {
+    data: any[];
+    rule: GrammarRule;
+    meta: any;
+}
+export type JavascriptDirective = {
+    body: GrammarTypeJS;
+} | {
+    head: GrammarTypeJS;
+};
+export interface ImportDirective {
+    import: string;
+    path?: boolean;
+}
+export interface ConfigDirective {
+    config: Dictionary<any>;
+}
+export interface GrammarDirective {
+    grammar: {
+        config?: Dictionary<any>;
+        rules: GrammarBuilderRule[];
+    };
+}
+export interface LexerDirective {
+    lexer: {
+        start?: string;
+        states: LexerStateDefinition[];
+    };
+}
+export interface GrammarBuilderRule {
+    name: string;
+    expressions: GrammarBuilderExpression[];
+    postprocess?: GrammarTypeJS | GrammarTypeBuiltIn | GrammarTypeTemplate;
+}
+export interface GrammarBuilderExpression {
+    symbols: GrammarBuilderSymbol[];
+    postprocess?: GrammarTypeJS | GrammarTypeBuiltIn | GrammarTypeTemplate;
+}
+export type GrammarBuilderSymbol = GrammarTypeRule | GrammarTypeRegex | GrammarTypeToken | GrammarTypeLiteral | GrammarBuilderSymbolRepeat | GrammarBuilderSymbolSubexpression;
+export interface GrammarBuilderSymbolSubexpression {
+    subexpression: GrammarBuilderExpression[];
+}
+export interface GrammarBuilderSymbolRepeat {
+    expression: GrammarBuilderSymbol;
+    repeat: "+" | "*" | "?";
+}
+export interface GrammarTypeRule {
+    rule: string;
+}
+export interface GrammarTypeRegex {
+    regex: string;
+    flags?: string;
+}
+export interface GrammarTypeToken {
+    token: string;
+}
+export interface GrammarTypeLiteral {
+    literal: string;
+    insensitive?: boolean;
+}
+export type GrammarTypeBuiltIn = {
+    builtin: string;
+};
+export type GrammarTypeTemplate = {
+    template: string;
+};
+export type GrammarTypeJS = {
+    js: string;
+};
+export type ParserAlgorithm = ((language: LanguageDefinition & {
+    tokens: TokenBuffer;
+    utility: ParserUtility;
+}, options?: any) => {
+    results: any[];
+    info?: any;
+});
+export type LanguageDirective = (JavascriptDirective | ImportDirective | ConfigDirective | GrammarDirective | LexerDirective);
+type GrammarRuleSymbolFunction = (data: LexerToken) => boolean;
+export interface GrammarRule {
+    name: string;
+    symbols: GrammarRuleSymbol[];
+    postprocess?: PostProcessor;
+}
+export type GrammarRuleSymbol = string | RegExp | GrammarTypeLiteral | GrammarTypeToken | GrammarRuleSymbolFunction;
+export interface GeneratorGrammarRule {
+    name: string;
+    symbols: GeneratorGrammarSymbol[];
+    postprocess?: GrammarTypeTemplate | GrammarTypeBuiltIn | GrammarTypeJS;
+}
+export type GeneratorGrammarSymbol = {
+    alias?: string;
+} & (GrammarTypeRule | GrammarTypeRegex | GrammarTypeLiteral | GrammarTypeToken | GrammarTypeJS);
+export interface LanguageDefinition {
+    lexer?: Lexer | LexerConfig;
+    grammar: {
+        start: string;
+        rules: Dictionary<GrammarRule[]>;
+    };
+}
+export interface TQRestorePoint {
+    historyIndex: number;
+    offset: number;
+}
+export interface Lexer {
+    next(): LexerToken | undefined;
+    feed(chunk?: string, state?: ReturnType<Lexer['state']>): void;
+    state(): any;
+    flush?(): void;
+}
+export interface LexerToken {
+    type?: string | undefined;
+    tag?: Set<string>;
+    value: string;
+    offset: number;
+    line: number;
+    column: number;
+}
+export interface LexerStatus {
+    index: number;
+    line: number;
+    column: number;
+    state: string;
+}
+export interface LexerStateDefinition {
+    name: string;
+    unmatched?: string;
+    default?: string;
+    rules: (LexerStateImportRule | LexerStateMatchRule)[];
+}
+export interface LexerStateImportRule {
+    import: string[];
+}
+export interface LexerStateMatchRule {
+    when: string | RegExp;
+    type?: string;
+    tag?: string[];
+    pop?: number | 'all';
+    highlight?: string;
+    inset?: number;
+    goto?: string;
+    set?: string;
+}
+export interface ResolvedStateDefinition {
+    name: string;
+    unmatched?: string;
+    rules: LexerStateMatchRule[];
+}
+export interface CompiledStateDefinition {
+    regexp: RegExp;
+    unmatched?: LexerStateMatchRule;
+    rules: LexerStateMatchRule[];
+}
+export interface LexerConfig {
+    start?: string;
+    states: Dictionary<LexerStateDefinition>;
+}
+export interface GeneratorState {
+    version: string;
+    config: Dictionary<string>;
+    head: string[];
+    body: string[];
+    lexer?: LexerConfig;
+    grammar: {
+        start: string;
+        rules: Dictionary<GeneratorGrammarRule[]>;
+        uuids: {
+            [key: string]: number;
+        };
+    };
+}
+export {};

package/build/typings.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=typings.js.map

package/build/utility/general.d.ts

@@ -1,55 +1,55 @@
-import { Dictionary, GrammarRuleSymbol } from "../typings";
-export declare class Collection<T> {
-    categorized: Dictionary<Dictionary<number>>;
-    private uncategorized;
-    items: T[];
-    constructor(ref?: T[]);
-    encode(ref: T): number;
-    decode(id: number | string): T;
-    has(ref: T): boolean;
-    redirect(source: T, target: T): void;
-    resolve(_: T): {
-        category: keyof Collection<T>['categorized'];
-        key: string;
-    } | void;
-    private addCategorized;
-    private addUncategorized;
-}
-export declare class SymbolCollection extends Collection<GrammarRuleSymbol> {
-    categorized: {
-        nonTerminal: {};
-        literalI: {};
-        literalS: {};
-        token: {};
-        regex: {};
-        function: {};
-    };
-    resolve(symbol: GrammarRuleSymbol): {
-        category: string;
-        key: string;
-    };
-}
-export declare class Matrix<T> {
-    private initial?;
-    private $x;
-    private $y;
-    get x(): number;
-    set x(x: number);
-    get y(): number;
-    set y(y: number);
-    matrix: GetCallbackOrValue<T>[][];
-    constructor(x: number, y: number, initial?: T | ((...args: any) => T));
-    get(x: number, y: number): T;
-    set(x: number, y: number, value: any): any;
-    resize(x: number, y: number): void;
-    static Array<T>(length: any, initial?: T | ((...args: any) => T)): GetCallbackOrValue<T>[];
-}
-export declare function Flatten(obj: any[] | {
-    [key: string]: any;
-}): FlatObject;
-export declare function Unflatten(items: FlatObject): any;
-type FlatObject = (boolean | number | string | (number[]) | {
-    [key: string]: number;
-})[];
-type GetCallbackOrValue<T> = T extends (...args: any) => any ? ReturnType<T> : T;
-export {};
+import { Dictionary, GrammarRuleSymbol } from "../typings";
+export declare class Collection<T> {
+    categorized: Dictionary<Dictionary<number>>;
+    uncategorized: Map<T, number>;
+    items: T[];
+    constructor(ref?: T[]);
+    encode(ref: T): number;
+    decode(id: number | string): T;
+    has(ref: T): boolean;
+    redirect(source: T, target: T): void;
+    resolve(_: T): {
+        category: keyof Collection<T>['categorized'];
+        key: string;
+    } | void;
+    private addCategorized;
+    private addUncategorized;
+}
+export declare class SymbolCollection extends Collection<GrammarRuleSymbol> {
+    categorized: {
+        nonTerminal: {};
+        literalI: {};
+        literalS: {};
+        token: {};
+        regex: {};
+        function: {};
+    };
+    resolve(symbol: GrammarRuleSymbol): {
+        category: string;
+        key: string;
+    };
+}
+export declare class Matrix<T> {
+    private initial?;
+    private $x;
+    private $y;
+    get x(): number;
+    set x(x: number);
+    get y(): number;
+    set y(y: number);
+    matrix: GetCallbackOrValue<T>[][];
+    constructor(x: number, y: number, initial?: T | ((...args: any) => T));
+    get(x: number, y: number): T;
+    set(x: number, y: number, value: any): any;
+    resize(x: number, y: number): void;
+    static Array<T>(length: any, initial?: T | ((...args: any) => T)): GetCallbackOrValue<T>[];
+}
+export declare function Flatten(obj: any[] | {
+    [key: string]: any;
+}): FlatObject;
+export declare function Unflatten(items: FlatObject): any;
+type FlatObject = (boolean | number | string | (number[]) | {
+    [key: string]: number;
+})[];
+type GetCallbackOrValue<T> = T extends (...args: any) => any ? ReturnType<T> : T;
+export {};