@ohos-ports/advanced-mark.js 3.0.0-beta.0

package/CHANGELOG.md

@@ -0,0 +1,107 @@
+
+### 3.0.0
+* Combine pattern become the default in the `mark()` API.
+* The default number of the `combineBy` (old name `combinePatterns`) option is increase from 10 to 100.
+* Added requirement for `g` flag in `markRegExp()` API when not using `acrossElements` option.
+* Dropped support to highlight RegExp groups without `d` flag.
+* Removed RegExpCreator module from the npm package.
+* Added the ability to abort a method execution on the 'each' callback.
+* Removed the 'execution' object from the 'filter ' and 'each' callbacks' info object.
+* Added support for CSS Custom Highlight API.
+* Dropped support of very older browsers.
+
+### 2.7.1
+* Fixed the 'filter' callback 'matchesSoFar' counter (3 parameter) that affected the mark() method with the 'combinePatterns' option.
+
+### 2.7.0
+* Added source code to the npm package.
+
+### 2.6.0
+* Added ability to mark inside iframes in shadow DOM.
+* Changed the way to truck iframes states (dropped using attribute).
+* Added ability to use HTMLCollection (returned by 'getElementsByClassName()' and 'getElementsByTagName()').
+
+### 2.5.0
+* Added ability to select iframe elements when using non-jQuery libraries and iframe elements are dynamically created by javascript.
+* Fixed multiple wrapping of highlighted text in mark elements that can occur on some conditions with `iframes` option (page contains several iframes and selecting several contexts). Previous 2.x.x versions correctly handle only one context.
+* Fixed bug that is related to old browsers in DOMIterator class, e.g. IE11. (introduced in v2.4.1)
+
+### 2.4.2
+* Fixed bug that occurs in `markRanges()` API then an array of ranges have a single item and a range `start` property is zero.
+
+### 2.4.1
+* Fixed infinite loop that can occur with `ignoreGroups` option in markRegExp() API with the conditional main group.
+* Fixed missing window object of the Node interface (causes an exception in virtual DOM environments when context is an array of elements).
+
+### 2.4.0
+* Fixed handling escaped wildcards characters (backslashes were stripped from searching string, e.g. 'C:\\\\\\\\*' resulted in 'C:\\\\*' and is treated as escape '*', not a wildcard)
+* Fixed breaking UTF-16 surrogate pairs and continues pairs of backslashes by joiners/punctuation
+* Slightly reduce a code size
+
+### 2.3.0
+
+* Added `preserveTerms` value for `separateWordSearch` option that allows highlight exact term(s) alone side with separate word(s).
+* Added 'startsWith' value for accuracy option that allows highlight whole word(s) just typing the start of it(s). It also works with `preserveTerms`.
+
+### 2.2.0
+
+* Added ability to mark line ranges (`markRanges()` API with `markLines` option).
+* Fixed handling `br` element in `getTextNodesAcross()` method.
+* Fixed negative value of the start index in `wrapRangeAcross()` method with `wrapAllRanges` option, which can occur in some cases.
+* An improvement that allows usage of RegExp conditional capturing groups with  `ignoreGroups` option in `markRegExp()` API.
+
+### 2.1.2
+
+* Fixed problem with 'jquery.mark.es6.js' module by adding `node.jquery.mark.es6.js` module, which contains `import $ from 'jquery';` statement necessary on Node.js.
+* Added missing `őŐűŰ` diacritic characters in RegExpCreator class.
+
+### 2.1.1
+
+* Fixed debug logging to the console.
+* Improved detection of custom window object and as a result getting a clear error message on the non-valid object.
+
+### 2.1.0
+
+* Fixed bug related using a wildcards character `*` with `wildcards : 'withSpaces'`, `acrossElements` , and `blockElementsBoundary` options.
+* Added supports for virtual DOM environments such as JSDOM. Thanks to [Tyler Nickerson](https://github.com/Nickersoft) for the contribution.
+
+### 2.0.0
+
+* Rewrote `DOMIterator` iframe related code. Added code sorting a custom array of elements by the DOM order -  can affect `markRanges()` method.
+* Rewrote `unwrapMatches()` method for performance reason.
+* Rewrote `getTextNodesAcross()` method (previously named as 'getTextNodesAcrossElements') to change the logic which determines does the two text nodes are separated by block element.
+* Rewrote `markRanges` related code (to simplify the code).
+* Changes in `mark()` and `markRegExp()` methods: the `filter` callback parameters that count mark elements has been changed to count matches. It can affect the old code that uses `acrossElements` option.
+* Simplified `getSeparatedKeywords()` method.
+* Got rid of empty sibling text nodes that are created when `Text.splitText()` method splits a text node at the start or/and at the end.
+* Changes in RegExpCreator class:
+  1. removed unnecessary escaping of characters in a RegExp character set
+  2. added ability to using string instead of array in 'ignorePunctuation' option and accuracy object
+  3. added code which remove duplicate from array of characters or synonyms
+
+### 1.1.2
+
+* Fixed bug related using a wildcards character `*` with `wildcards : 'withSpaces'`, `acrossElements` , and `blockElementsBoundary` options.
+* Fixed types path in package.json.
+
+### 1.1.1
+
+* Fixed bug that affect wrapping separate groups across elements with combination of `acrossElements`, `cacheTextNodes`, and `separateGroups` options
+* Implemented missing `offset` property in filter callback info object with combination of `acrossElements` and `separateGroups` options
+* Corrected some mistakes in TypeScript declaration files
+
+### 1.1.0
+
+* Added ability to extend the default boundary elements with custom elements (`blockElementsBoundary` option)
+
+### 1.0.3
+
+* Added TypeScript types declaration files.
+* Rewrote `setupIgnoreJoinersRegExp()` method to get rid of a capturing group in `createSynonymsRegExp()` method (it breaks group/term relation when using synonyms with combinePatterns option).
+* Rewrote `createDiacriticsRegExp()` method to reduce the size.
+* Optimized cache object code.
+* Corrected `Elements boundaries` doc.
+
+### 1.0.2
+
+* Initial release

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 angezid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# advanced-mark.js
+
+[![npm](https://img.shields.io/npm/v/advanced-mark.js)](https://www.npmjs.com/package/advanced-mark.js)
+
+### A fast JavaScript library to highlight any text on a browser page
+
+### Features
+-  Pure Vanilla Javascript
+-  Zero Dependencies
+-  Iframes Support
+-  Shadow DOM Support
+-  Diacritics Support
+-  CSS Custom Highlight API
+-  Virtual DOMs like JSDOM Support
+-  Highly Customizable
+
+See [Playground](https://angezid.github.io/advanced-mark.js/playground-v3) which can speak better than any words.  
+See [Performance page](https://angezid.github.io/advanced-mark.js/performance-v3) which demonstrate the library performance.  
+[Documentation](https://angezid.github.io/advanced-mark.js/doc-v3).
+
+Happy highlighting!
+
+### License
+
+[MIT](LICENSE)

package/dist/jquery.mark.d.ts

@@ -0,0 +1,235 @@
+
+// Type definitions for advanced-mark.js v3.0.0
+// Based on "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/mark.js"
+
+/// <reference types="jquery"/>
+
+declare namespace Mark {
+
+  interface BoundaryObject {
+    tags?: string[];
+    extend?: boolean;
+    char?: string;
+  }
+
+  interface ShadowObject {
+    style: string;
+  }
+
+  interface IframesObject {
+    style: string;
+  }
+
+  interface AccuracyObject {
+    value: 'exactly' | 'startsWith' | 'complementary';
+    limiters: string | string[];
+  }
+
+  interface MarkOptions {
+    element?: string;
+    window?: Window;
+    className?: string;
+    exclude?: string | string[];
+    separateWordSearch?: boolean | 'preserveTerms';
+    acrossElements?: boolean;
+    accuracy?: 'partially' | 'exactly' | 'startsWith' | 'complementary' | AccuracyObject;
+    diacritics?: boolean;
+    synonyms?: { [index: string] : string | string[] };
+    caseSensitive?: boolean;
+    ignoreJoiners?: boolean;
+    ignorePunctuation?: string | string[];
+    wildcards?: 'disabled' | 'enabled' | 'withSpaces';
+    iframes?: boolean | IframesObject;
+    iframesTimeout?: number;
+
+    highlight?: Highlight;
+    highlightName?: string;
+    staticRanges?: boolean;
+    rangeAcrossElements?: boolean;
+    combineby?: number;
+    blockElementsBoundary?: boolean | BoundaryObject;
+    shadowDOM?: boolean | ShadowObject;
+
+    filter?(
+      nodeOrArray: Text | Text[], term: string, totalMatchesSoFar: number, termMatchesSoFar: number, filterInfo: MarkFilterInfo
+    ) : boolean;
+    each?(elementOrRange: Element | StaticRange | Range, eachInfo: MarkEachInfo) : void;
+    done?(totalMarks: number, totalMatches: number, termStats: TermStats) : void;
+
+    noMatch?(term: string[]) : void;
+    debug?: boolean;
+    log?: object;
+  }
+
+  interface MarkFilterInfo {
+    match: RegExpExecArray;
+    matchStart?: boolean;
+    count: number;
+    abort: boolean;
+  }
+
+  interface MarkEachInfo {
+    match: RegExpExecArray;
+    matchStart?: boolean;
+    count: number;
+    abort: boolean;
+  }
+
+  interface TermStats {
+    [index: string] : number;
+  }
+
+  interface RegExpOptions {
+    element?: string;
+    className?: string;
+    exclude?: string | string[];
+    acrossElements?: boolean;
+    ignoreGroups?: number;
+    iframes?: boolean | IframesObject;
+    iframesTimeout?: number;
+
+    highlight?: Highlight;
+    highlightName?: string;
+    staticRanges?: boolean;
+    rangeAcrossElements?: boolean;
+    separateGroups?: boolean;
+    wrapAllRanges?: boolean;
+    blockElementsBoundary?: boolean | BoundaryObject;
+    shadowDOM?: boolean | ShadowObject;
+
+    filter?(nodeOrArray: Text | Text[], regexp: string, matchesSoFar: number, filterInfo: RegExpFilterInfo) : boolean;
+    each?(elementOrRange: Element | StaticRange | Range, eachInfo: RegExpEachInfo) : void;
+    done?(totalMarks: number, totalMatches: number) : void;
+
+    noMatch?(regexp: string) : void;
+    debug?: boolean;
+    log?: object;
+  }
+
+  interface RegExpFilterInfo {
+    match: RegExpExecArray;
+    matchStart?: boolean;
+    count: number;
+    groupIndex?: number;
+    abort: boolean;
+  }
+
+  interface RegExpEachInfo {
+    match: RegExpExecArray;
+    matchStart?: boolean;
+    count: number;
+    groupIndex?: number;
+    groupStart?: boolean;
+    abort: boolean;
+  }
+
+  interface RangesOptions {
+    element?: string;
+    className?: string;
+    exclude?: string | string[];
+    iframes?: boolean | IframesObject;
+    iframesTimeout?: number;
+
+    highlight?: Highlight;
+    highlightName?: string;
+    staticRanges?: boolean;
+    rangeAcrossElements?: boolean;
+    wrapAllRanges?: boolean;
+    markLines?: boolean;
+    shadowDOM?: boolean | ShadowObject;
+
+    filter?(nodeOrArray: Text | Text[], range: MarkRange, matchingString: string, currentIndex: number) : boolean;
+    each?(elementOrRange: Element | StaticRange | Range, range: MarkRange, eachInfo: RangeEachInfo) : void;
+    done?(totalMarks: number, totalRanges: number) : void;
+
+    noMatch?(range: MarkRange) : void;
+    debug?: boolean;
+    log?: object;
+  }
+
+  interface MarkRange {
+    start: number;
+    length: number;
+  }
+
+  interface RangeEachInfo {
+    matchStart?: boolean;
+    count: number;
+  }
+
+  interface UnmarkOptions {
+    element?: string;
+    className?: string;
+    exclude?: string | string[];
+    iframes?: boolean | IframesObject;
+    iframesTimeout?: number;
+    shadowDOM?: boolean;
+    highlight?: Highlight;
+    highlightName?: string | string[];
+
+    done?() : void;
+    debug?: boolean;
+    log?: object;
+  }
+}
+
+declare class Mark {
+  constructor(context: string | HTMLElement | ReadonlyArray<HTMLElement> | NodeList | null);
+
+  /**
+  * Highlights the specified search terms.
+  * @param term The string to be marked. Can also be an array with multiple strings.
+  * Note that keywords will be escaped. If you need to mark unescaped keywords (e.g. containing a pattern),
+  * have a look at the `markRegExp()`
+  * @param options Optional options
+  */
+  mark(term: string | ReadonlyArray<string>, options?: Mark.MarkOptions) : void;
+
+  /**
+  * Highlights a custom regular expression.
+  * @param regexp The regular expression to be marked. Example: /Lor[^]?m/gmi.
+  * Note that the `g` flag must be present when `acrossElements : true`, otherwise the RegExp is recompiled.
+  * @param options Optional options
+  */
+  markRegExp(regexp: RegExp, options?: Mark.RegExpOptions) : void;
+
+  /**
+  * A method to mark ranges with a start position and length. They will be applied
+  * to text nodes in the specified context.
+  * @param ranges An array of objects with a start and length property.
+  * Note that the start positions must be specified including whitespace characters.
+  * @param options Optional options
+  */
+  markRanges(ranges: ReadonlyArray<Mark.MarkRange>, options?: Mark.RangesOptions) : void;
+
+  /**
+  * A method to remove mark elements created by mark.js and normalize text nodes.
+  * @param options Optional options
+  */
+  unmark(options?: Mark.UnmarkOptions) : void;
+}
+
+export = Mark;
+
+/* augment JQuery */
+declare global {
+  interface JQuery {
+    mark(term: string | ReadonlyArray<string>, options?: Mark.MarkOptions) : void;
+
+    markRegExp(regexp: RegExp, options?: Mark.RegExpOptions) : void;
+
+    markRanges(ranges: ReadonlyArray<Mark.MarkRange>, options?: Mark.RangesOptions) : void;
+
+    unmark(options?: Mark.UnmarkOptions) : void;
+  }
+
+  interface JQueryStatic {
+    mark(term: string | ReadonlyArray<string>, options?: Mark.MarkOptions) : void;
+
+    markRegExp(regexp: RegExp, options?: Mark.RegExpOptions) : void;
+
+    markRanges(ranges: ReadonlyArray<Mark.MarkRange>, options?: Mark.RangesOptions) : void;
+
+    unmark(options?: Mark.UnmarkOptions) : void;
+  }
+}

package/dist/jquery.mark.es6.d.ts

@@ -0,0 +1,235 @@
+
+// Type definitions for advanced-mark.js v3.0.0
+// Based on "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/mark.js"
+
+/// <reference types="jquery"/>
+
+declare namespace Mark {
+
+  interface BoundaryObject {
+    tags?: string[];
+    extend?: boolean;
+    char?: string;
+  }
+
+  interface ShadowObject {
+    style: string;
+  }
+
+  interface IframesObject {
+    style: string;
+  }
+
+  interface AccuracyObject {
+    value: 'exactly' | 'startsWith' | 'complementary';
+    limiters: string | string[];
+  }
+
+  interface MarkOptions {
+    element?: string;
+    window?: Window;
+    className?: string;
+    exclude?: string | string[];
+    separateWordSearch?: boolean | 'preserveTerms';
+    acrossElements?: boolean;
+    accuracy?: 'partially' | 'exactly' | 'startsWith' | 'complementary' | AccuracyObject;
+    diacritics?: boolean;
+    synonyms?: { [index: string] : string | string[] };
+    caseSensitive?: boolean;
+    ignoreJoiners?: boolean;
+    ignorePunctuation?: string | string[];
+    wildcards?: 'disabled' | 'enabled' | 'withSpaces';
+    iframes?: boolean | IframesObject;
+    iframesTimeout?: number;
+
+    highlight?: Highlight;
+    highlightName?: string;
+    staticRanges?: boolean;
+    rangeAcrossElements?: boolean;
+    combineby?: number;
+    blockElementsBoundary?: boolean | BoundaryObject;
+    shadowDOM?: boolean | ShadowObject;
+
+    filter?(
+      nodeOrArray: Text | Text[], term: string, totalMatchesSoFar: number, termMatchesSoFar: number, filterInfo: MarkFilterInfo
+    ) : boolean;
+    each?(elementOrRange: Element | StaticRange | Range, eachInfo: MarkEachInfo) : void;
+    done?(totalMarks: number, totalMatches: number, termStats: TermStats) : void;
+
+    noMatch?(term: string[]) : void;
+    debug?: boolean;
+    log?: object;
+  }
+
+  interface MarkFilterInfo {
+    match: RegExpExecArray;
+    matchStart?: boolean;
+    count: number;
+    abort: boolean;
+  }
+
+  interface MarkEachInfo {
+    match: RegExpExecArray;
+    matchStart?: boolean;
+    count: number;
+    abort: boolean;
+  }
+
+  interface TermStats {
+    [index: string] : number;
+  }
+
+  interface RegExpOptions {
+    element?: string;
+    className?: string;
+    exclude?: string | string[];
+    acrossElements?: boolean;
+    ignoreGroups?: number;
+    iframes?: boolean | IframesObject;
+    iframesTimeout?: number;
+
+    highlight?: Highlight;
+    highlightName?: string;
+    staticRanges?: boolean;
+    rangeAcrossElements?: boolean;
+    separateGroups?: boolean;
+    wrapAllRanges?: boolean;
+    blockElementsBoundary?: boolean | BoundaryObject;
+    shadowDOM?: boolean | ShadowObject;
+
+    filter?(nodeOrArray: Text | Text[], regexp: string, matchesSoFar: number, filterInfo: RegExpFilterInfo) : boolean;
+    each?(elementOrRange: Element | StaticRange | Range, eachInfo: RegExpEachInfo) : void;
+    done?(totalMarks: number, totalMatches: number) : void;
+
+    noMatch?(regexp: string) : void;
+    debug?: boolean;
+    log?: object;
+  }
+
+  interface RegExpFilterInfo {
+    match: RegExpExecArray;
+    matchStart?: boolean;
+    count: number;
+    groupIndex?: number;
+    abort: boolean;
+  }
+
+  interface RegExpEachInfo {
+    match: RegExpExecArray;
+    matchStart?: boolean;
+    count: number;
+    groupIndex?: number;
+    groupStart?: boolean;
+    abort: boolean;
+  }
+
+  interface RangesOptions {
+    element?: string;
+    className?: string;
+    exclude?: string | string[];
+    iframes?: boolean | IframesObject;
+    iframesTimeout?: number;
+
+    highlight?: Highlight;
+    highlightName?: string;
+    staticRanges?: boolean;
+    rangeAcrossElements?: boolean;
+    wrapAllRanges?: boolean;
+    markLines?: boolean;
+    shadowDOM?: boolean | ShadowObject;
+
+    filter?(nodeOrArray: Text | Text[], range: MarkRange, matchingString: string, currentIndex: number) : boolean;
+    each?(elementOrRange: Element | StaticRange | Range, range: MarkRange, eachInfo: RangeEachInfo) : void;
+    done?(totalMarks: number, totalRanges: number) : void;
+
+    noMatch?(range: MarkRange) : void;
+    debug?: boolean;
+    log?: object;
+  }
+
+  interface MarkRange {
+    start: number;
+    length: number;
+  }
+
+  interface RangeEachInfo {
+    matchStart?: boolean;
+    count: number;
+  }
+
+  interface UnmarkOptions {
+    element?: string;
+    className?: string;
+    exclude?: string | string[];
+    iframes?: boolean | IframesObject;
+    iframesTimeout?: number;
+    shadowDOM?: boolean;
+    highlight?: Highlight;
+    highlightName?: string | string[];
+
+    done?() : void;
+    debug?: boolean;
+    log?: object;
+  }
+}
+
+declare class Mark {
+  constructor(context: string | HTMLElement | ReadonlyArray<HTMLElement> | NodeList | null);
+
+  /**
+  * Highlights the specified search terms.
+  * @param term The string to be marked. Can also be an array with multiple strings.
+  * Note that keywords will be escaped. If you need to mark unescaped keywords (e.g. containing a pattern),
+  * have a look at the `markRegExp()`
+  * @param options Optional options
+  */
+  mark(term: string | ReadonlyArray<string>, options?: Mark.MarkOptions) : void;
+
+  /**
+  * Highlights a custom regular expression.
+  * @param regexp The regular expression to be marked. Example: /Lor[^]?m/gmi.
+  * Note that the `g` flag must be present when `acrossElements : true`, otherwise the RegExp is recompiled.
+  * @param options Optional options
+  */
+  markRegExp(regexp: RegExp, options?: Mark.RegExpOptions) : void;
+
+  /**
+  * A method to mark ranges with a start position and length. They will be applied
+  * to text nodes in the specified context.
+  * @param ranges An array of objects with a start and length property.
+  * Note that the start positions must be specified including whitespace characters.
+  * @param options Optional options
+  */
+  markRanges(ranges: ReadonlyArray<Mark.MarkRange>, options?: Mark.RangesOptions) : void;
+
+  /**
+  * A method to remove mark elements created by mark.js and normalize text nodes.
+  * @param options Optional options
+  */
+  unmark(options?: Mark.UnmarkOptions) : void;
+}
+
+export = Mark;
+
+/* augment JQuery */
+declare global {
+  interface JQuery {
+    mark(term: string | ReadonlyArray<string>, options?: Mark.MarkOptions) : void;
+
+    markRegExp(regexp: RegExp, options?: Mark.RegExpOptions) : void;
+
+    markRanges(ranges: ReadonlyArray<Mark.MarkRange>, options?: Mark.RangesOptions) : void;
+
+    unmark(options?: Mark.UnmarkOptions) : void;
+  }
+
+  interface JQueryStatic {
+    mark(term: string | ReadonlyArray<string>, options?: Mark.MarkOptions) : void;
+
+    markRegExp(regexp: RegExp, options?: Mark.RegExpOptions) : void;
+
+    markRanges(ranges: ReadonlyArray<Mark.MarkRange>, options?: Mark.RangesOptions) : void;
+
+    unmark(options?: Mark.UnmarkOptions) : void;
+  }
+}