Fixed broken icon path in Snapcraft build

snap/snapcraft.yaml

@@ -11,7 +11,7 @@ description: |
 
 grade: stable
 confinement: strict
-icon: ./build/icons/512x512.png
+icon: ./build/512x512.png
 license: MIT
 compression: lzo
 platforms:

src/main/modules/Filters/FilterLang.d.ts

@@ -1,11 +1,11 @@
 /** Provides information pointing to a location within a source. */
 export interface Location {
   /** Line in the parsed source (1-based). */
-  readonly line: number
+  readonly line: number;
   /** Column in the parsed source (1-based). */
-  readonly column: number
+  readonly column: number;
   /** Offset in the parsed source (0-based). */
-  readonly offset: number
+  readonly offset: number;
 }
 
 /**
@@ -15,71 +15,75 @@ export interface Location {
  * The GrammarLocation class in Peggy is a good example.
  */
 export interface GrammarSourceObject {
-  readonly toString: () => string
+  readonly toString: () => string;
 
   /**
    * If specified, allows the grammar source to be embedded in a larger file
    * at some offset.
    */
-  readonly offset?: undefined | ((loc: Location) => Location)
+  readonly offset?: undefined | ((loc: Location) => Location);
 }
 
 /**
  * Most often, you just use a string with the file name.
  */
-export type GrammarSource = string | GrammarSourceObject
+export type GrammarSource = string | GrammarSourceObject;
 
 /** The `start` and `end` position's of an object within the source. */
 export interface LocationRange {
   /**
    * A string or object that was supplied to the `parse()` call as the
    * `grammarSource` option.
    */
-  readonly source: GrammarSource
+  readonly source: GrammarSource;
   /** Position at the beginning of the expression. */
-  readonly start: Location
+  readonly start: Location;
   /** Position after the end of the expression. */
-  readonly end: Location
+  readonly end: Location;
 }
 
 /**
  * Expected a literal string, like `"foo"i`.
  */
 export interface LiteralExpectation {
-  readonly type: 'literal'
-  readonly text: string
-  readonly ignoreCase: boolean
+  readonly type: "literal";
+  readonly text: string;
+  readonly ignoreCase: boolean;
 }
 
 /**
  * Range of characters, like `a-z`
  */
-export type ClassRange = [start: string, end: string]
+export type ClassRange = [
+  start: string,
+  end: string,
+]
 
-export interface ClassParts extends Array<string | ClassRange> {}
+export interface ClassParts extends Array<string | ClassRange> {
+}
 
 /**
  * Expected a class, such as `[^acd-gz]i`
  */
 export interface ClassExpectation {
-  readonly type: 'class'
-  readonly parts: ClassParts
-  readonly inverted: boolean
-  readonly ignoreCase: boolean
+  readonly type: "class";
+  readonly parts: ClassParts;
+  readonly inverted: boolean;
+  readonly ignoreCase: boolean;
 }
 
 /**
  * Expected any character, with `.`
  */
 export interface AnyExpectation {
-  readonly type: 'any'
+  readonly type: "any";
 }
 
 /**
  * Expected the end of input.
  */
 export interface EndExpectation {
-  readonly type: 'end'
+  readonly type: "end";
 }
 
 /**
@@ -88,16 +92,16 @@ export interface EndExpectation {
  * function.
  */
 export interface OtherExpectation {
-  readonly type: 'other'
-  readonly description: string
+  readonly type: "other";
+  readonly description: string;
 }
 
 export type Expectation =
   | AnyExpectation
   | ClassExpectation
   | EndExpectation
   | LiteralExpectation
-  | OtherExpectation
+  | OtherExpectation;
 
 /**
  * Pass an array of these into `SyntaxError.prototype.format()`
@@ -106,9 +110,9 @@ export interface SourceText {
   /**
    * Identifier of an input that was used as a grammarSource in parse().
    */
-  readonly source: GrammarSource
+  readonly source: GrammarSource;
   /** Source text of the input. */
-  readonly text: string
+  readonly text: string;
 }
 
 export declare class SyntaxError extends Error {
@@ -119,87 +123,87 @@ export declare class SyntaxError extends Error {
    * @param found Any text that will appear as found in the input instead of
    *   expected
    */
-  static buildMessage(expected: Expectation[], found?: string | null | undefined): string
-  readonly message: string
-  readonly expected: Expectation[]
-  readonly found: string | null | undefined
-  readonly location: LocationRange
-  readonly name: string
+  static buildMessage(expected: Expectation[], found?: string | null | undefined): string;
+  readonly message: string;
+  readonly expected: Expectation[];
+  readonly found: string | null | undefined;
+  readonly location: LocationRange;
+  readonly name: string;
   constructor(
     message: string,
     expected: Expectation[],
     found: string | null,
-    location: LocationRange
-  )
+    location: LocationRange,
+  );
 
   /**
    * With good sources, generates a feature-rich error message pointing to the
    * error in the input.
    * @param sources List of {source, text} objects that map to the input.
    */
-  format(sources: SourceText[]): string
+  format(sources: SourceText[]): string;
 }
 
 /**
  * Trace execution of the parser.
  */
 export interface ParserTracer {
-  trace: (event: ParserTracerEvent) => void
+  trace: (event: ParserTracerEvent) => void;
 }
 
-export type ParserTracerEvent =
-  | {
-      readonly type: 'rule.enter'
-      readonly rule: string
+export type ParserTracerEvent
+  = {
+      readonly type: "rule.enter";
+      readonly rule: string;
       readonly location: LocationRange
     }
   | {
-      readonly type: 'rule.fail'
-      readonly rule: string
+      readonly type: "rule.fail";
+      readonly rule: string;
       readonly location: LocationRange
     }
   | {
-      readonly type: 'rule.match'
-      readonly rule: string
+      readonly type: "rule.match";
+      readonly rule: string;
       readonly location: LocationRange
       /** Return value from the rule. */
-      readonly result: unknown
-    }
+      readonly result: unknown;
+    };
 
-export type StartRuleNames = 'filterQuery'
-export interface ParseOptions<T extends StartRuleNames = 'filterQuery'> {
+export type StartRuleNames = "filterQuery";
+export interface ParseOptions<T extends StartRuleNames = "filterQuery"> {
   /**
    * String or object that will be attached to the each `LocationRange` object
    * created by the parser. For example, this can be path to the parsed file
    * or even the File object.
    */
-  readonly grammarSource?: GrammarSource
-  readonly startRule?: T
-  readonly tracer?: ParserTracer
+  readonly grammarSource?: GrammarSource;
+  readonly startRule?: T;
+  readonly tracer?: ParserTracer;
 
   // Internal use only:
-  readonly peg$library?: boolean
+  readonly peg$library?: boolean;
   // Internal use only:
-  peg$currPos?: number
+  peg$currPos?: number;
   // Internal use only:
-  peg$silentFails?: number
+  peg$silentFails?: number;
   // Internal use only:
-  peg$maxFailExpected?: Expectation[]
+  peg$maxFailExpected?: Expectation[];
   // Extra application-specific properties
-  [key: string]: unknown
+  [key: string]: unknown;
 }
 
-export declare const StartRules: StartRuleNames[]
-export declare const parse: typeof ParseFunction
+export declare const StartRules: StartRuleNames[];
+export declare const parse: typeof ParseFunction;
 
 // Overload of ParseFunction for each allowedStartRule
 
-declare function ParseFunction<Options extends ParseOptions<'filterQuery'>>(
+declare function ParseFunction<Options extends ParseOptions<"filterQuery">>(
   input: string,
-  options?: Options
-): any
+  options?: Options,
+): any;
 
 declare function ParseFunction<Options extends ParseOptions<StartRuleNames>>(
   input: string,
-  options?: Options
-): any
+  options?: Options,
+): any;