ot-builder-cli 1.3.3 → 1.5.1

package/CHANGELOG.json

@@ -2,7 +2,94 @@
   "name": "ot-builder-cli",
   "entries": [
     {
-      "date": "Sat, 18 Dec 2021 01:17:29 GMT",
+      "date": "Sat, 02 Apr 2022 01:38:49 GMT",
+      "tag": "ot-builder-cli_v1.5.1",
+      "version": "1.5.1",
+      "comments": {
+        "patch": [
+          {
+            "author": "beachball",
+            "package": "ot-builder-cli",
+            "comment": "Bump ot-builder to v1.5.1",
+            "commit": "f87981f0891315771cda43fb56a3d8e85731a0af"
+          },
+          {
+            "author": "beachball",
+            "package": "ot-builder-cli",
+            "comment": "Bump @ot-builder/cli-help-shower to v1.5.1",
+            "commit": "f87981f0891315771cda43fb56a3d8e85731a0af"
+          },
+          {
+            "author": "beachball",
+            "package": "ot-builder-cli",
+            "comment": "Bump @ot-builder/cli-shared to v1.5.1",
+            "commit": "f87981f0891315771cda43fb56a3d8e85731a0af"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Sat, 26 Mar 2022 01:37:00 GMT",
+      "tag": "ot-builder-cli_v1.5.0",
+      "version": "1.5.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "beachball",
+            "package": "ot-builder-cli",
+            "comment": "Bump ot-builder to v1.5.0",
+            "commit": "0d6eb83609255ffdfd147ed0610aab1aa424b357"
+          },
+          {
+            "author": "beachball",
+            "package": "ot-builder-cli",
+            "comment": "Bump @ot-builder/cli-help-shower to v1.5.0",
+            "commit": "0d6eb83609255ffdfd147ed0610aab1aa424b357"
+          },
+          {
+            "author": "beachball",
+            "package": "ot-builder-cli",
+            "comment": "Bump @ot-builder/cli-shared to v1.5.0",
+            "commit": "0d6eb83609255ffdfd147ed0610aab1aa424b357"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Sat, 26 Feb 2022 01:27:19 GMT",
+      "tag": "ot-builder-cli_v1.4.0",
+      "version": "1.4.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "otbbuilder-dev@users.noreply.github.com",
+            "package": "ot-builder-cli",
+            "commit": "d5ef5ade3424ec81b7545c9967badddeb9cc8f1b",
+            "comment": "Enhance OTBCLI with better subset, drop and transform-glyphs"
+          },
+          {
+            "author": "beachball",
+            "package": "ot-builder-cli",
+            "comment": "Bump ot-builder to v1.4.0",
+            "commit": "f1c3eedd84cadff44ee97d878a245b451ce7bd59"
+          },
+          {
+            "author": "beachball",
+            "package": "ot-builder-cli",
+            "comment": "Bump @ot-builder/cli-help-shower to v1.4.0",
+            "commit": "f1c3eedd84cadff44ee97d878a245b451ce7bd59"
+          },
+          {
+            "author": "beachball",
+            "package": "ot-builder-cli",
+            "comment": "Bump @ot-builder/cli-shared to v1.4.0",
+            "commit": "f1c3eedd84cadff44ee97d878a245b451ce7bd59"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Sat, 18 Dec 2021 01:19:54 GMT",
       "tag": "ot-builder-cli_v1.3.3",
       "version": "1.3.3",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,43 @@
 # Change Log - ot-builder-cli
 
-This log was last generated on Sat, 18 Dec 2021 01:17:29 GMT and should not be manually modified.
+This log was last generated on Sat, 02 Apr 2022 01:38:49 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 1.5.1
+
+Sat, 02 Apr 2022 01:38:49 GMT
+
+### Patches
+
+- Bump ot-builder to v1.5.1
+- Bump @ot-builder/cli-help-shower to v1.5.1
+- Bump @ot-builder/cli-shared to v1.5.1
+
+## 1.5.0
+
+Sat, 26 Mar 2022 01:37:00 GMT
+
+### Minor changes
+
+- Bump ot-builder to v1.5.0
+- Bump @ot-builder/cli-help-shower to v1.5.0
+- Bump @ot-builder/cli-shared to v1.5.0
+
+## 1.4.0
+
+Sat, 26 Feb 2022 01:27:19 GMT
+
+### Minor changes
+
+- Enhance OTBCLI with better subset, drop and transform-glyphs (otbbuilder-dev@users.noreply.github.com)
+- Bump ot-builder to v1.4.0
+- Bump @ot-builder/cli-help-shower to v1.4.0
+- Bump @ot-builder/cli-shared to v1.4.0
+
 ## 1.3.3
 
-Sat, 18 Dec 2021 01:17:29 GMT
+Sat, 18 Dec 2021 01:19:54 GMT
 
 ### Patches
 

package/lib/argv-parser/index.d.ts

@@ -2,8 +2,9 @@ export interface ParseState {
     next(): ParseState;
     isEof(): this is ParsingEof;
     isOption(...options: string[]): this is ParsingOption;
+    expectOption(...options: string[]): string;
     isArgument(): this is ParsingArgument;
-    nextArgument(): ParseResult<string>;
+    expectArgument(): string;
     reportParseErrorPosition(): string;
 }
 export interface ParsingEof {

package/lib/argv-parser/index.js

@@ -15,14 +15,14 @@ class ParseArgvImpl {
     constructor(argv, cp) {
         this.argv = argv;
         this.cp = cp;
-        this.eof = this.cp < this.argv.length;
+        this.eof = this.cp >= this.argv.length;
         this.option = this.argument = this.argv[cp];
     }
     next() {
         return new ParseArgvImpl(this.argv, this.cp + 1);
     }
     isEof() {
-        return this.cp >= this.argv.length;
+        return this.eof;
     }
     isOption(...options) {
         if (this.isEof())
@@ -38,9 +38,19 @@ class ParseArgvImpl {
         }
         return false;
     }
+    expectOption(...options) {
+        if (!this.isOption(...options))
+            throw new TypeError("Not option.");
+        return this.option;
+    }
     isArgument() {
         return !this.isEof() && !this.isOption();
     }
+    expectArgument() {
+        if (!this.isArgument())
+            throw new TypeError("Not argument.");
+        return this.argument;
+    }
     nextArgument() {
         const nx = this.next();
         if (nx.isArgument()) {

package/lib/create-grammar.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGrammar = void 0;
 const consolidate_1 = require("./syntax/actions/consolidate");
+const drop_1 = require("./syntax/actions/drop");
 const gc_1 = require("./syntax/actions/gc");
 const intro_1 = require("./syntax/actions/intro");
 const merge_1 = require("./syntax/actions/merge");
@@ -9,6 +10,7 @@ const rebase_1 = require("./syntax/actions/rebase");
 const save_1 = require("./syntax/actions/save");
 const save_head_1 = require("./syntax/actions/save-head");
 const subset_1 = require("./syntax/actions/subset");
+const transform_glyphs_1 = require("./syntax/actions/transform-glyphs");
 const alternate_1 = require("./syntax/composite/alternate");
 const main_command_1 = require("./syntax/composite/main-command");
 const possessive_repeat_1 = require("./syntax/composite/possessive-repeat");
@@ -32,9 +34,11 @@ function createGrammar() {
         save_1.SaveSyntax,
         save_head_1.SaveHeadSyntax,
         rebase_1.RebaseSyntax,
-        gc_1.GcSyntax,
-        subset_1.SubsetSyntax,
+        transform_glyphs_1.TransformGlyphsSyntax,
         merge_1.MergeSyntax,
+        subset_1.SubsetSyntax,
+        drop_1.DropSyntax,
+        gc_1.GcSyntax,
         consolidate_1.ConsolidateSyntax,
         set_optimize_level_1.SetOptimizationLevelSyntax,
         set_recalc_os2_avg_char_width_1.SetRecalcOs2AvgCharWidthSyntax

package/lib/sub-parsers/unicode-ranges/datatypes.d.ts

@@ -0,0 +1,6 @@
+export declare type RangeDecl = {
+    isExclusion: boolean;
+    start: number;
+    end: number;
+};
+//# sourceMappingURL=datatypes.d.ts.map

package/lib/sub-parsers/unicode-ranges/datatypes.js

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

package/lib/sub-parsers/unicode-ranges/generated.d.ts

@@ -0,0 +1,157 @@
+import { RangeDecl } from "./datatypes";
+declare type Nullable<T> = T | null;
+export declare enum ASTKinds {
+    start = 0,
+    Ranges_1 = 1,
+    Ranges_2 = 2,
+    Range_1 = 3,
+    Range_2 = 4,
+    CodePoint = 5,
+    Prefix_1 = 6,
+    Prefix_2 = 7,
+    Prefix_3 = 8,
+    Separator_1 = 9,
+    Separator_2 = 10,
+    _ = 11,
+    __ = 12,
+    ___ = 13
+}
+export declare class start {
+    kind: ASTKinds.start;
+    rgs: Ranges;
+    ranges: RangeDecl[];
+    constructor(rgs: Ranges);
+}
+export declare type Ranges = Ranges_1 | Ranges_2;
+export declare class Ranges_1 {
+    kind: ASTKinds.Ranges_1;
+    car: Range;
+    cdr: Ranges;
+    ranges: RangeDecl[];
+    constructor(car: Range, cdr: Ranges);
+}
+export declare class Ranges_2 {
+    kind: ASTKinds.Ranges_2;
+    range: Range;
+    ranges: RangeDecl[];
+    constructor(range: Range);
+}
+export declare type Range = Range_1 | Range_2;
+export declare class Range_1 {
+    kind: ASTKinds.Range_1;
+    exclude: Nullable<string>;
+    start: CodePoint;
+    end: CodePoint;
+    codeRange: RangeDecl;
+    constructor(exclude: Nullable<string>, start: CodePoint, end: CodePoint);
+}
+export declare class Range_2 {
+    kind: ASTKinds.Range_2;
+    exclude: Nullable<string>;
+    at: CodePoint;
+    codeRange: RangeDecl;
+    constructor(exclude: Nullable<string>, at: CodePoint);
+}
+export declare class CodePoint {
+    kind: ASTKinds.CodePoint;
+    literal: string;
+    value: number;
+    constructor(literal: string);
+}
+export declare type Prefix = Prefix_1 | Prefix_2 | Prefix_3;
+export declare type Prefix_1 = string;
+export declare type Prefix_2 = string;
+export declare type Prefix_3 = string;
+export declare type Separator = Separator_1 | Separator_2;
+export interface Separator_1 {
+    kind: ASTKinds.Separator_1;
+}
+export declare type Separator_2 = ___;
+export declare type _ = string;
+export declare type __ = string;
+export interface ___ {
+    kind: ASTKinds.___;
+}
+export declare class Parser {
+    private readonly input;
+    private pos;
+    private negating;
+    private memoSafe;
+    constructor(input: string);
+    reset(pos: PosInfo): void;
+    finished(): boolean;
+    clearMemos(): void;
+    protected $scope$start$memo: Map<number, [Nullable<start>, PosInfo]>;
+    protected $scope$Ranges$memo: Map<number, [Nullable<Ranges>, PosInfo]>;
+    protected $scope$Range$memo: Map<number, [Nullable<Range>, PosInfo]>;
+    protected $scope$CodePoint$memo: Map<number, [Nullable<CodePoint>, PosInfo]>;
+    protected $scope$Prefix$memo: Map<number, [Nullable<Prefix>, PosInfo]>;
+    protected $scope$Separator$memo: Map<number, [Nullable<Separator>, PosInfo]>;
+    protected $scope$_$memo: Map<number, [Nullable<_>, PosInfo]>;
+    protected $scope$__$memo: Map<number, [Nullable<__>, PosInfo]>;
+    protected $scope$___$memo: Map<number, [Nullable<___>, PosInfo]>;
+    matchstart($$dpth: number, $$cr?: ErrorTracker): Nullable<start>;
+    matchRanges($$dpth: number, $$cr?: ErrorTracker): Nullable<Ranges>;
+    matchRanges_1($$dpth: number, $$cr?: ErrorTracker): Nullable<Ranges_1>;
+    matchRanges_2($$dpth: number, $$cr?: ErrorTracker): Nullable<Ranges_2>;
+    matchRange($$dpth: number, $$cr?: ErrorTracker): Nullable<Range>;
+    matchRange_1($$dpth: number, $$cr?: ErrorTracker): Nullable<Range_1>;
+    matchRange_2($$dpth: number, $$cr?: ErrorTracker): Nullable<Range_2>;
+    matchCodePoint($$dpth: number, $$cr?: ErrorTracker): Nullable<CodePoint>;
+    matchPrefix($$dpth: number, $$cr?: ErrorTracker): Nullable<Prefix>;
+    matchPrefix_1($$dpth: number, $$cr?: ErrorTracker): Nullable<Prefix_1>;
+    matchPrefix_2($$dpth: number, $$cr?: ErrorTracker): Nullable<Prefix_2>;
+    matchPrefix_3($$dpth: number, $$cr?: ErrorTracker): Nullable<Prefix_3>;
+    matchSeparator($$dpth: number, $$cr?: ErrorTracker): Nullable<Separator>;
+    matchSeparator_1($$dpth: number, $$cr?: ErrorTracker): Nullable<Separator_1>;
+    matchSeparator_2($$dpth: number, $$cr?: ErrorTracker): Nullable<Separator_2>;
+    match_($$dpth: number, $$cr?: ErrorTracker): Nullable<_>;
+    match__($$dpth: number, $$cr?: ErrorTracker): Nullable<__>;
+    match___($$dpth: number, $$cr?: ErrorTracker): Nullable<___>;
+    test(): boolean;
+    parse(): ParseResult;
+    mark(): PosInfo;
+    private loop;
+    private run;
+    private choice;
+    private regexAccept;
+    private tryConsume;
+    private noConsume;
+    private negate;
+    private memoise;
+}
+export declare function parse(s: string): ParseResult;
+export interface ParseResult {
+    ast: Nullable<start>;
+    errs: SyntaxErr[];
+}
+export interface PosInfo {
+    readonly overallPos: number;
+    readonly line: number;
+    readonly offset: number;
+}
+export interface RegexMatch {
+    readonly kind: "RegexMatch";
+    readonly negated: boolean;
+    readonly literal: string;
+}
+export declare type EOFMatch = {
+    kind: "EOF";
+    negated: boolean;
+};
+export declare type MatchAttempt = RegexMatch | EOFMatch;
+export declare class SyntaxErr {
+    pos: PosInfo;
+    expmatches: MatchAttempt[];
+    constructor(pos: PosInfo, expmatches: MatchAttempt[]);
+    toString(): string;
+}
+declare class ErrorTracker {
+    private mxpos;
+    private regexset;
+    private pmatches;
+    record(pos: PosInfo, result: any, att: MatchAttempt): void;
+    getErr(): SyntaxErr | null;
+}
+export {};
+//# sourceMappingURL=generated.d.ts.map

package/lib/sub-parsers/unicode-ranges/generated.js

@@ -0,0 +1,494 @@
+"use strict";
+/* AutoGenerated Code, changes may be overwritten
+* INPUT GRAMMAR:
+* ---
+* import { RangeDecl } from "./datatypes";
+* ---
+* start       := __ rgs=Ranges __
+*                 .ranges = RangeDecl[] { return this.rgs.ranges }
+* Ranges      := car=Range Separator cdr=Ranges
+*                 .ranges = RangeDecl[] { return [this.car.codeRange, ...this.cdr.ranges] }
+*              | range=Range
+*                 .ranges = RangeDecl[] { return [this.range.codeRange] }
+* Range       := _ exclude='-'? _ start=CodePoint _ '..' _ end=CodePoint _
+*                 .codeRange = RangeDecl {
+*                     return {
+*                         isExclusion: !!this.exclude,
+*                         start: this.start.value,
+*                         end:this.end.value
+*                     }
+*                 }
+*              | _ exclude='-'? _ at=CodePoint _
+*                 .codeRange = RangeDecl {
+*                     return { isExclusion: !!this.exclude, start: this.at.value, end:this.at.value }
+*                 }
+* CodePoint   := Prefix? literal='[0-9A-Fa-f]+'
+*                 .value = number { return parseInt(this.literal, 16) }
+* Prefix      := 'U\+' | '0x' | '0X'
+* Separator   := _ '[,;]' __
+*              | ___
+* _           := '[ \t]*'
+* __          := '(?:[ \t]|(?:#[^\r\n]*)?[\r\n])*'
+* ___         := _ '(?:#[^\r\n]*)?[\r\n]' __
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyntaxErr = exports.parse = exports.Parser = exports.CodePoint = exports.Range_2 = exports.Range_1 = exports.Ranges_2 = exports.Ranges_1 = exports.start = exports.ASTKinds = void 0;
+var ASTKinds;
+(function (ASTKinds) {
+    ASTKinds[ASTKinds["start"] = 0] = "start";
+    ASTKinds[ASTKinds["Ranges_1"] = 1] = "Ranges_1";
+    ASTKinds[ASTKinds["Ranges_2"] = 2] = "Ranges_2";
+    ASTKinds[ASTKinds["Range_1"] = 3] = "Range_1";
+    ASTKinds[ASTKinds["Range_2"] = 4] = "Range_2";
+    ASTKinds[ASTKinds["CodePoint"] = 5] = "CodePoint";
+    ASTKinds[ASTKinds["Prefix_1"] = 6] = "Prefix_1";
+    ASTKinds[ASTKinds["Prefix_2"] = 7] = "Prefix_2";
+    ASTKinds[ASTKinds["Prefix_3"] = 8] = "Prefix_3";
+    ASTKinds[ASTKinds["Separator_1"] = 9] = "Separator_1";
+    ASTKinds[ASTKinds["Separator_2"] = 10] = "Separator_2";
+    ASTKinds[ASTKinds["_"] = 11] = "_";
+    ASTKinds[ASTKinds["__"] = 12] = "__";
+    ASTKinds[ASTKinds["___"] = 13] = "___";
+})(ASTKinds = exports.ASTKinds || (exports.ASTKinds = {}));
+class start {
+    constructor(rgs) {
+        this.kind = ASTKinds.start;
+        this.rgs = rgs;
+        this.ranges = (() => {
+            return this.rgs.ranges;
+        })();
+    }
+}
+exports.start = start;
+class Ranges_1 {
+    constructor(car, cdr) {
+        this.kind = ASTKinds.Ranges_1;
+        this.car = car;
+        this.cdr = cdr;
+        this.ranges = (() => {
+            return [this.car.codeRange, ...this.cdr.ranges];
+        })();
+    }
+}
+exports.Ranges_1 = Ranges_1;
+class Ranges_2 {
+    constructor(range) {
+        this.kind = ASTKinds.Ranges_2;
+        this.range = range;
+        this.ranges = (() => {
+            return [this.range.codeRange];
+        })();
+    }
+}
+exports.Ranges_2 = Ranges_2;
+class Range_1 {
+    constructor(exclude, start, end) {
+        this.kind = ASTKinds.Range_1;
+        this.exclude = exclude;
+        this.start = start;
+        this.end = end;
+        this.codeRange = (() => {
+            return {
+                isExclusion: !!this.exclude,
+                start: this.start.value,
+                end: this.end.value
+            };
+        })();
+    }
+}
+exports.Range_1 = Range_1;
+class Range_2 {
+    constructor(exclude, at) {
+        this.kind = ASTKinds.Range_2;
+        this.exclude = exclude;
+        this.at = at;
+        this.codeRange = (() => {
+            return { isExclusion: !!this.exclude, start: this.at.value, end: this.at.value };
+        })();
+    }
+}
+exports.Range_2 = Range_2;
+class CodePoint {
+    constructor(literal) {
+        this.kind = ASTKinds.CodePoint;
+        this.literal = literal;
+        this.value = (() => {
+            return parseInt(this.literal, 16);
+        })();
+    }
+}
+exports.CodePoint = CodePoint;
+class Parser {
+    constructor(input) {
+        this.negating = false;
+        this.memoSafe = true;
+        this.$scope$start$memo = new Map();
+        this.$scope$Ranges$memo = new Map();
+        this.$scope$Range$memo = new Map();
+        this.$scope$CodePoint$memo = new Map();
+        this.$scope$Prefix$memo = new Map();
+        this.$scope$Separator$memo = new Map();
+        this.$scope$_$memo = new Map();
+        this.$scope$__$memo = new Map();
+        this.$scope$___$memo = new Map();
+        this.pos = { overallPos: 0, line: 1, offset: 0 };
+        this.input = input;
+    }
+    reset(pos) {
+        this.pos = pos;
+    }
+    finished() {
+        return this.pos.overallPos === this.input.length;
+    }
+    clearMemos() {
+        this.$scope$start$memo.clear();
+        this.$scope$Ranges$memo.clear();
+        this.$scope$Range$memo.clear();
+        this.$scope$CodePoint$memo.clear();
+        this.$scope$Prefix$memo.clear();
+        this.$scope$Separator$memo.clear();
+        this.$scope$_$memo.clear();
+        this.$scope$__$memo.clear();
+        this.$scope$___$memo.clear();
+    }
+    matchstart($$dpth, $$cr) {
+        return this.memoise(() => {
+            return this.run($$dpth, () => {
+                let $scope$rgs;
+                let $$res = null;
+                if (true
+                    && this.match__($$dpth + 1, $$cr) !== null
+                    && ($scope$rgs = this.matchRanges($$dpth + 1, $$cr)) !== null
+                    && this.match__($$dpth + 1, $$cr) !== null) {
+                    $$res = new start($scope$rgs);
+                }
+                return $$res;
+            });
+        }, this.$scope$start$memo);
+    }
+    matchRanges($$dpth, $$cr) {
+        return this.memoise(() => {
+            return this.choice([
+                () => this.matchRanges_1($$dpth + 1, $$cr),
+                () => this.matchRanges_2($$dpth + 1, $$cr),
+            ]);
+        }, this.$scope$Ranges$memo);
+    }
+    matchRanges_1($$dpth, $$cr) {
+        return this.run($$dpth, () => {
+            let $scope$car;
+            let $scope$cdr;
+            let $$res = null;
+            if (true
+                && ($scope$car = this.matchRange($$dpth + 1, $$cr)) !== null
+                && this.matchSeparator($$dpth + 1, $$cr) !== null
+                && ($scope$cdr = this.matchRanges($$dpth + 1, $$cr)) !== null) {
+                $$res = new Ranges_1($scope$car, $scope$cdr);
+            }
+            return $$res;
+        });
+    }
+    matchRanges_2($$dpth, $$cr) {
+        return this.run($$dpth, () => {
+            let $scope$range;
+            let $$res = null;
+            if (true
+                && ($scope$range = this.matchRange($$dpth + 1, $$cr)) !== null) {
+                $$res = new Ranges_2($scope$range);
+            }
+            return $$res;
+        });
+    }
+    matchRange($$dpth, $$cr) {
+        return this.memoise(() => {
+            return this.choice([
+                () => this.matchRange_1($$dpth + 1, $$cr),
+                () => this.matchRange_2($$dpth + 1, $$cr),
+            ]);
+        }, this.$scope$Range$memo);
+    }
+    matchRange_1($$dpth, $$cr) {
+        return this.run($$dpth, () => {
+            let $scope$exclude;
+            let $scope$start;
+            let $scope$end;
+            let $$res = null;
+            if (true
+                && this.match_($$dpth + 1, $$cr) !== null
+                && (($scope$exclude = this.regexAccept(String.raw `(?:-)`, $$dpth + 1, $$cr)) || true)
+                && this.match_($$dpth + 1, $$cr) !== null
+                && ($scope$start = this.matchCodePoint($$dpth + 1, $$cr)) !== null
+                && this.match_($$dpth + 1, $$cr) !== null
+                && this.regexAccept(String.raw `(?:..)`, $$dpth + 1, $$cr) !== null
+                && this.match_($$dpth + 1, $$cr) !== null
+                && ($scope$end = this.matchCodePoint($$dpth + 1, $$cr)) !== null
+                && this.match_($$dpth + 1, $$cr) !== null) {
+                $$res = new Range_1($scope$exclude, $scope$start, $scope$end);
+            }
+            return $$res;
+        });
+    }
+    matchRange_2($$dpth, $$cr) {
+        return this.run($$dpth, () => {
+            let $scope$exclude;
+            let $scope$at;
+            let $$res = null;
+            if (true
+                && this.match_($$dpth + 1, $$cr) !== null
+                && (($scope$exclude = this.regexAccept(String.raw `(?:-)`, $$dpth + 1, $$cr)) || true)
+                && this.match_($$dpth + 1, $$cr) !== null
+                && ($scope$at = this.matchCodePoint($$dpth + 1, $$cr)) !== null
+                && this.match_($$dpth + 1, $$cr) !== null) {
+                $$res = new Range_2($scope$exclude, $scope$at);
+            }
+            return $$res;
+        });
+    }
+    matchCodePoint($$dpth, $$cr) {
+        return this.memoise(() => {
+            return this.run($$dpth, () => {
+                let $scope$literal;
+                let $$res = null;
+                if (true
+                    && ((this.matchPrefix($$dpth + 1, $$cr)) || true)
+                    && ($scope$literal = this.regexAccept(String.raw `(?:[0-9A-Fa-f]+)`, $$dpth + 1, $$cr)) !== null) {
+                    $$res = new CodePoint($scope$literal);
+                }
+                return $$res;
+            });
+        }, this.$scope$CodePoint$memo);
+    }
+    matchPrefix($$dpth, $$cr) {
+        return this.memoise(() => {
+            return this.choice([
+                () => this.matchPrefix_1($$dpth + 1, $$cr),
+                () => this.matchPrefix_2($$dpth + 1, $$cr),
+                () => this.matchPrefix_3($$dpth + 1, $$cr),
+            ]);
+        }, this.$scope$Prefix$memo);
+    }
+    matchPrefix_1($$dpth, $$cr) {
+        return this.regexAccept(String.raw `(?:U\+)`, $$dpth + 1, $$cr);
+    }
+    matchPrefix_2($$dpth, $$cr) {
+        return this.regexAccept(String.raw `(?:0x)`, $$dpth + 1, $$cr);
+    }
+    matchPrefix_3($$dpth, $$cr) {
+        return this.regexAccept(String.raw `(?:0X)`, $$dpth + 1, $$cr);
+    }
+    matchSeparator($$dpth, $$cr) {
+        return this.memoise(() => {
+            return this.choice([
+                () => this.matchSeparator_1($$dpth + 1, $$cr),
+                () => this.matchSeparator_2($$dpth + 1, $$cr),
+            ]);
+        }, this.$scope$Separator$memo);
+    }
+    matchSeparator_1($$dpth, $$cr) {
+        return this.run($$dpth, () => {
+            let $$res = null;
+            if (true
+                && this.match_($$dpth + 1, $$cr) !== null
+                && this.regexAccept(String.raw `(?:[,;])`, $$dpth + 1, $$cr) !== null
+                && this.match__($$dpth + 1, $$cr) !== null) {
+                $$res = { kind: ASTKinds.Separator_1, };
+            }
+            return $$res;
+        });
+    }
+    matchSeparator_2($$dpth, $$cr) {
+        return this.match___($$dpth + 1, $$cr);
+    }
+    match_($$dpth, $$cr) {
+        return this.memoise(() => {
+            return this.regexAccept(String.raw `(?:[ \t]*)`, $$dpth + 1, $$cr);
+        }, this.$scope$_$memo);
+    }
+    match__($$dpth, $$cr) {
+        return this.memoise(() => {
+            return this.regexAccept(String.raw `(?:(?:[ \t]|(?:#[^\r\n]*)?[\r\n])*)`, $$dpth + 1, $$cr);
+        }, this.$scope$__$memo);
+    }
+    match___($$dpth, $$cr) {
+        return this.memoise(() => {
+            return this.run($$dpth, () => {
+                let $$res = null;
+                if (true
+                    && this.match_($$dpth + 1, $$cr) !== null
+                    && this.regexAccept(String.raw `(?:(?:#[^\r\n]*)?[\r\n])`, $$dpth + 1, $$cr) !== null
+                    && this.match__($$dpth + 1, $$cr) !== null) {
+                    $$res = { kind: ASTKinds.___, };
+                }
+                return $$res;
+            });
+        }, this.$scope$___$memo);
+    }
+    test() {
+        const mrk = this.mark();
+        const res = this.matchstart(0);
+        const ans = res !== null;
+        this.reset(mrk);
+        return ans;
+    }
+    parse() {
+        const mrk = this.mark();
+        const res = this.matchstart(0);
+        if (res)
+            return { ast: res, errs: [] };
+        this.reset(mrk);
+        const rec = new ErrorTracker();
+        this.clearMemos();
+        this.matchstart(0, rec);
+        const err = rec.getErr();
+        return { ast: res, errs: err !== null ? [err] : [] };
+    }
+    mark() {
+        return this.pos;
+    }
+    loop(func, star = false) {
+        const mrk = this.mark();
+        const res = [];
+        for (;;) {
+            const t = func();
+            if (t === null) {
+                break;
+            }
+            res.push(t);
+        }
+        if (star || res.length > 0) {
+            return res;
+        }
+        this.reset(mrk);
+        return null;
+    }
+    run($$dpth, fn) {
+        const mrk = this.mark();
+        const res = fn();
+        if (res !== null)
+            return res;
+        this.reset(mrk);
+        return null;
+    }
+    choice(fns) {
+        for (const f of fns) {
+            const res = f();
+            if (res !== null) {
+                return res;
+            }
+        }
+        return null;
+    }
+    regexAccept(match, dpth, cr) {
+        return this.run(dpth, () => {
+            const reg = new RegExp(match, "y");
+            const mrk = this.mark();
+            reg.lastIndex = mrk.overallPos;
+            const res = this.tryConsume(reg);
+            if (cr) {
+                cr.record(mrk, res, {
+                    kind: "RegexMatch",
+                    // We substring from 3 to len - 1 to strip off the
+                    // non-capture group syntax added as a WebKit workaround
+                    literal: match.substring(3, match.length - 1),
+                    negated: this.negating,
+                });
+            }
+            return res;
+        });
+    }
+    tryConsume(reg) {
+        const res = reg.exec(this.input);
+        if (res) {
+            let lineJmp = 0;
+            let lind = -1;
+            for (let i = 0; i < res[0].length; ++i) {
+                if (res[0][i] === "\n") {
+                    ++lineJmp;
+                    lind = i;
+                }
+            }
+            this.pos = {
+                overallPos: reg.lastIndex,
+                line: this.pos.line + lineJmp,
+                offset: lind === -1 ? this.pos.offset + res[0].length : (res[0].length - lind - 1)
+            };
+            return res[0];
+        }
+        return null;
+    }
+    noConsume(fn) {
+        const mrk = this.mark();
+        const res = fn();
+        this.reset(mrk);
+        return res;
+    }
+    negate(fn) {
+        const mrk = this.mark();
+        const oneg = this.negating;
+        this.negating = !oneg;
+        const res = fn();
+        this.negating = oneg;
+        this.reset(mrk);
+        return res === null ? true : null;
+    }
+    memoise(rule, memo) {
+        const $scope$pos = this.mark();
+        const $scope$memoRes = memo.get($scope$pos.overallPos);
+        if (this.memoSafe && $scope$memoRes !== undefined) {
+            this.reset($scope$memoRes[1]);
+            return $scope$memoRes[0];
+        }
+        const $scope$result = rule();
+        if (this.memoSafe)
+            memo.set($scope$pos.overallPos, [$scope$result, this.mark()]);
+        return $scope$result;
+    }
+}
+exports.Parser = Parser;
+function parse(s) {
+    const p = new Parser(s);
+    return p.parse();
+}
+exports.parse = parse;
+class SyntaxErr {
+    constructor(pos, expmatches) {
+        this.pos = pos;
+        this.expmatches = [...expmatches];
+    }
+    toString() {
+        return `Syntax Error at line ${this.pos.line}:${this.pos.offset}. Expected one of ${this.expmatches.map(x => x.kind === "EOF" ? " EOF" : ` ${x.negated ? 'not ' : ''}'${x.literal}'`)}`;
+    }
+}
+exports.SyntaxErr = SyntaxErr;
+class ErrorTracker {
+    constructor() {
+        this.mxpos = { overallPos: -1, line: -1, offset: -1 };
+        this.regexset = new Set();
+        this.pmatches = [];
+    }
+    record(pos, result, att) {
+        if ((result === null) === att.negated)
+            return;
+        if (pos.overallPos > this.mxpos.overallPos) {
+            this.mxpos = pos;
+            this.pmatches = [];
+            this.regexset.clear();
+        }
+        if (this.mxpos.overallPos === pos.overallPos) {
+            if (att.kind === "RegexMatch") {
+                if (!this.regexset.has(att.literal))
+                    this.pmatches.push(att);
+                this.regexset.add(att.literal);
+            }
+            else {
+                this.pmatches.push(att);
+            }
+        }
+    }
+    getErr() {
+        if (this.mxpos.overallPos !== -1)
+            return new SyntaxErr(this.mxpos, this.pmatches);
+        return null;
+    }
+}
+//# sourceMappingURL=generated.js.map

package/lib/syntax/actions/drop.d.ts

@@ -0,0 +1,3 @@
+import { CliAction, Syntax } from "../../command";
+export declare const DropSyntax: Syntax<null | CliAction>;
+//# sourceMappingURL=drop.d.ts.map

package/lib/syntax/actions/drop.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropSyntax = void 0;
+const cli_help_shower_1 = require("@ot-builder/cli-help-shower");
+const ot_builder_1 = require("ot-builder");
+const argv_parser_1 = require("../../argv-parser");
+exports.DropSyntax = {
+    handle: st => {
+        if (!st.isOption("--drop-otl", "--drop-math", "--drop-base", "--drop-hints"))
+            return (0, argv_parser_1.ParseResult)(st, null);
+        const opt = st.option;
+        return (0, argv_parser_1.ParseResult)(st.next(), async (state) => {
+            const entry = state.pop();
+            if (!entry)
+                throw new RangeError("Stack size invalid. No font to do handle.");
+            switch (opt) {
+                case "--drop-otl": {
+                    entry.font.gsub = null;
+                    entry.font.gpos = null;
+                    entry.font.gdef = null;
+                    break;
+                }
+                case "--drop-math": {
+                    entry.font.math = null;
+                    break;
+                }
+                case "--drop-base": {
+                    entry.font.base = null;
+                    break;
+                }
+                case "--drop-hints": {
+                    if (ot_builder_1.Ot.Font.isTtf(entry.font)) {
+                        entry.font.fpgm = null;
+                        entry.font.prep = null;
+                        entry.font.cvt = null;
+                        entry.font.vdmx = null;
+                    }
+                    for (const g of entry.font.glyphs.decideOrder())
+                        g.hints = null;
+                    break;
+                }
+            }
+            state.push(entry);
+        });
+    },
+    displayHelp(shower) {
+        shower.message(cli_help_shower_1.Style.Option `--drop-otl`);
+        shower
+            .indent("")
+            .message("Drops OTL information of the font. Removes GSUB, GPOS and GDEF tables.");
+        shower.message(cli_help_shower_1.Style.Option `--drop-base`);
+        shower.indent("").message("Drops BASE table of the font.");
+        shower.message(cli_help_shower_1.Style.Option `--drop-math`);
+        shower.indent("").message("Drops MATH table of the font.");
+        shower.message(cli_help_shower_1.Style.Option `--drop-hints`);
+        shower.indent("").message("Drops hinting information of the font");
+    }
+};
+//# sourceMappingURL=drop.js.map

package/lib/syntax/actions/rebase.js

@@ -8,12 +8,13 @@ exports.RebaseSyntax = {
     handle: st => {
         if (!st.isOption("--rebase"))
             return (0, argv_parser_1.ParseResult)(st, null);
-        const prArg = st.nextArgument();
-        return (0, argv_parser_1.ParseResult)(prArg.progress.next(), async (state) => {
+        st = st.next();
+        const arg = st.expectArgument();
+        return (0, argv_parser_1.ParseResult)(st.next(), async (state) => {
             const entry = state.pop();
             if (!entry)
                 throw new RangeError("Stack size invalid. No font to rebase.");
-            const newUpm = parseFloat(prArg.result) || entry.font.head.unitsPerEm;
+            const newUpm = parseFloat(arg) || entry.font.head.unitsPerEm;
             console.log(`Rebase ${entry} to ${newUpm}`);
             ot_builder_1.CliProc.rebaseFont(entry.font, newUpm);
             state.push(entry);

package/lib/syntax/actions/save-head.js

@@ -9,13 +9,14 @@ exports.SaveHeadSyntax = {
     handle: st => {
         if (!st.isOption("+o", "++save"))
             return (0, argv_parser_1.ParseResult)(st, null);
-        const prPath = st.nextArgument();
-        return (0, argv_parser_1.ParseResult)(prPath.progress.next(), async (state) => {
+        st = st.next();
+        const path = st.expectArgument();
+        return (0, argv_parser_1.ParseResult)(st.next(), async (state) => {
             const entry = state.shift();
             if (!entry)
                 throw new RangeError("Stack size invalid. No font to save.");
-            console.log(`Save ${entry} -> ${prPath.result}`);
-            await (0, save_1.saveFontToFile)(prPath.result, entry.font, (0, cli_shared_1.inferSaveCfg)(state, entry.font));
+            console.log(`Save ${entry} -> ${path}`);
+            await (0, save_1.saveFontToFile)(path, entry.font, (0, cli_shared_1.inferSaveCfg)(state, entry.font));
         });
     },
     displayHelp(shower) {

package/lib/syntax/actions/save.js

@@ -11,13 +11,14 @@ exports.SaveSyntax = {
     handle: st => {
         if (!st.isOption("-o", "--save"))
             return (0, argv_parser_1.ParseResult)(st, null);
-        const prPath = st.nextArgument();
-        return (0, argv_parser_1.ParseResult)(prPath.progress.next(), async (state) => {
+        st = st.next();
+        const path = st.expectArgument();
+        return (0, argv_parser_1.ParseResult)(st.next(), async (state) => {
             const entry = state.pop();
             if (!entry)
                 throw new RangeError("Stack size invalid. No font to save.");
-            console.log(`Save ${entry} -> ${prPath.result}`);
-            await saveFontToFile(prPath.result, entry.font, (0, cli_shared_1.inferSaveCfg)(state, entry.font));
+            console.log(`Save ${entry} -> ${path}`);
+            await saveFontToFile(path, entry.font, (0, cli_shared_1.inferSaveCfg)(state, entry.font));
         });
     },
     displayHelp(shower) {

package/lib/syntax/actions/subset.js

@@ -1,21 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubsetSyntax = void 0;
+const Fs = require("fs");
 const cli_help_shower_1 = require("@ot-builder/cli-help-shower");
 const ot_builder_1 = require("ot-builder");
 const argv_parser_1 = require("../../argv-parser");
+const ParseUnicodeRanges = require("../../sub-parsers/unicode-ranges/generated");
 exports.SubsetSyntax = {
     handle: st => {
         if (!st.isOption("--subset"))
             return (0, argv_parser_1.ParseResult)(st, null);
-        const prArg = st.nextArgument();
-        return (0, argv_parser_1.ParseResult)(prArg.progress.next(), async (state) => {
+        st = st.next();
+        let parser, argument;
+        if (st.isOption("--file", "--unicodes", "--unicodes-file")) {
+            switch (st.option) {
+                case "--file":
+                    parser = new FileParser(new PlainTextParser());
+                    break;
+                case "--unicodes":
+                    parser = new UnicodeRangesParser();
+                    break;
+                case "--unicodes-file":
+                    parser = new FileParser(new UnicodeRangesParser());
+                    break;
+                default:
+                    throw new Error("Unreachable");
+            }
+            st = st.next();
+            argument = st.expectArgument();
+        }
+        else {
+            parser = new PlainTextParser();
+            argument = st.expectArgument();
+        }
+        return (0, argv_parser_1.ParseResult)(st.next(), async (state) => {
             const entry = state.pop();
             if (!entry)
                 throw new RangeError("Stack size invalid. No font to subset.");
             console.log(`Subset ${entry}`);
             const gcBefore = entry.font.glyphs.decideOrder().length;
-            ot_builder_1.CliProc.subsetFont(entry.font, prArg.result, ot_builder_1.Ot.ListGlyphStoreFactory);
+            ot_builder_1.CliProc.subsetFont(entry.font, await parser.parse(argument), ot_builder_1.Ot.ListGlyphStoreFactory);
             const gcAfter = entry.font.glyphs.decideOrder().length;
             state.push(entry);
             console.log(`  Glyphs: ${gcAfter} / ${gcBefore}`);
@@ -23,7 +47,56 @@ exports.SubsetSyntax = {
     },
     displayHelp(shower) {
         shower.message(cli_help_shower_1.Style.Option `--subset`, cli_help_shower_1.Style.Param `text`);
-        shower.indent("").message("Subset the font at the stack top according to the text given.");
+        shower
+            .indent("")
+            .message(cli_help_shower_1.Style.Option `--subset`, cli_help_shower_1.Style.Option `--file`, cli_help_shower_1.Style.Param `path`)
+            .message(cli_help_shower_1.Style.Option `--subset`, cli_help_shower_1.Style.Option `--unicodes`, cli_help_shower_1.Style.Param `codes`)
+            .message(cli_help_shower_1.Style.Option `--subset`, cli_help_shower_1.Style.Option `--unicodes-file`, cli_help_shower_1.Style.Param `path`);
+        shower
+            .indent("")
+            .message("Subset the font at the stack top according to the text or unicode ranges given.")
+            .message(...["Option", cli_help_shower_1.Style.Option `--unicodes`, "is specified by a comma/semicolon"], ...["separated list of hex values or ranges (using", cli_help_shower_1.Style.Arg `..`, "operator),"], ...["optionally prefixed with", cli_help_shower_1.Style.Arg `U+`, "or", cli_help_shower_1.Style.Arg `0x`, "."], ...["Prefixing a range with operator", cli_help_shower_1.Style.Arg `-`, "indicates exclusion, and"], ...["will exclude the specified range from the character set to be kept."], ...["For example, the following parameter:"]);
+        shower
+            .indent("    ")
+            .message(cli_help_shower_1.Style.Option `--unicodes`, cli_help_shower_1.Style.Arg `'00..7F,-30..39,2000..206F'`);
+        shower
+            .indent("")
+            .message("Will subset the font with Basic ASCII and General Punctuation block,", "but without number digits.");
     }
 };
+class PlainTextParser {
+    async parse(argument) {
+        return argument;
+    }
+}
+class UnicodeRangesParser {
+    async parse(argument) {
+        const setChars = new Set();
+        const pr = ParseUnicodeRanges.parse(argument);
+        if (pr.errs.length || !pr.ast)
+            throw new Error("Unable to parse unicode ranges: " + pr.errs[0].toString());
+        for (const rg of pr.ast.ranges) {
+            if (rg.isExclusion) {
+                for (let ch = rg.start; ch <= rg.end; ch++) {
+                    setChars.delete(String.fromCodePoint(ch));
+                }
+            }
+            else {
+                for (let ch = rg.start; ch <= rg.end; ch++) {
+                    setChars.add(String.fromCodePoint(ch));
+                }
+            }
+        }
+        return setChars;
+    }
+}
+class FileParser {
+    constructor(subParser) {
+        this.subParser = subParser;
+    }
+    async parse(path) {
+        const body = await Fs.promises.readFile(path, "utf-8");
+        return this.subParser.parse(body);
+    }
+}
 //# sourceMappingURL=subset.js.map

package/lib/syntax/actions/transform-glyphs.d.ts

@@ -0,0 +1,3 @@
+import { CliAction, Syntax } from "../../command";
+export declare const TransformGlyphsSyntax: Syntax<null | CliAction>;
+//# sourceMappingURL=transform-glyphs.d.ts.map

package/lib/syntax/actions/transform-glyphs.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformGlyphsSyntax = void 0;
+const cli_help_shower_1 = require("@ot-builder/cli-help-shower");
+const ot_builder_1 = require("ot-builder");
+const argv_parser_1 = require("../../argv-parser");
+exports.TransformGlyphsSyntax = {
+    handle: st => {
+        if (!st.isOption("--transform-glyphs"))
+            return (0, argv_parser_1.ParseResult)(st, null);
+        st = st.next();
+        const prArg = st.expectArgument();
+        const tfmArgs = prArg.split(",");
+        const transform = {
+            xx: parseFloat(tfmArgs[0].trim()),
+            yx: parseFloat(tfmArgs[1].trim()),
+            xy: parseFloat(tfmArgs[2].trim()),
+            yy: parseFloat(tfmArgs[3].trim()),
+            dx: parseFloat(tfmArgs[4].trim()),
+            dy: parseFloat(tfmArgs[5].trim())
+        };
+        return (0, argv_parser_1.ParseResult)(st.next(), async (state) => {
+            const entry = state.pop();
+            if (!entry)
+                throw new RangeError("Stack size invalid. No font to do GC.");
+            ot_builder_1.CliProc.inPlaceTransformFontGlyph(entry.font, transform);
+            state.push(entry);
+        });
+    },
+    displayHelp(shower) {
+        shower.message(cli_help_shower_1.Style.Option `--transform-glyphs`, cli_help_shower_1.Style.Param `xx,yx,xy,yy,dx,dy`);
+        shower
+            .indent("")
+            .message("Perform a 2x3 affine transform to all glyphs' geometries in the font.", "Composite fonts will be flattened.");
+    }
+};
+//# sourceMappingURL=transform-glyphs.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ot-builder-cli",
-  "version": "1.3.3",
+  "version": "1.5.1",
   "bin": {
     "otb-cli": "./bin/otb-cli"
   },
@@ -28,12 +28,12 @@
   "dependencies": {
     "tslib": "^2.0.0",
     "chalk": "^4.1.1",
-    "ot-builder": "1.3.3",
-    "@ot-builder/cli-help-shower": "1.3.3",
-    "@ot-builder/cli-shared": "1.3.3"
+    "ot-builder": "1.5.1",
+    "@ot-builder/cli-help-shower": "1.5.1",
+    "@ot-builder/cli-shared": "1.5.1"
   },
   "devDependencies": {
     "@types/jest": "^26.0.23",
-    "jest": "^27.0.6"
+    "jest": "^27.5.1"
   }
 }