kn-cli 1.0.24 → 1.0.26

package/templates/dev/template_admin/tools/iconfont/node_modules/svgicons2svgfont/node_modules/svg-pathdata/src/SVGPathData.ts

@@ -0,0 +1,90 @@
+import { encodeSVGPath } from "./SVGPathDataEncoder";
+import { SVGPathDataParser } from "./SVGPathDataParser";
+import { SVGPathDataTransformer } from "./SVGPathDataTransformer";
+import { TransformableSVG } from "./TransformableSVG";
+import { SVGCommand } from "./types";
+
+export class SVGPathData extends TransformableSVG {
+  commands: SVGCommand[];
+  constructor(content: string | SVGCommand[]) {
+    super();
+    if ("string" === typeof content) {
+      this.commands = SVGPathData.parse(content);
+    } else {
+      this.commands = content;
+    }
+  }
+
+  encode() {
+    return SVGPathData.encode(this.commands);
+  }
+
+  getBounds() {
+    const boundsTransform = SVGPathDataTransformer.CALCULATE_BOUNDS();
+
+    this.transform(boundsTransform);
+    return boundsTransform;
+  }
+
+  transform(
+    transformFunction: (input: SVGCommand) => SVGCommand | SVGCommand[],
+  ) {
+    const newCommands = [];
+
+    for (const command of this.commands) {
+      const transformedCommand = transformFunction(command);
+
+      if (Array.isArray(transformedCommand)) {
+        newCommands.push(...transformedCommand);
+      } else {
+        newCommands.push(transformedCommand);
+      }
+    }
+    this.commands = newCommands;
+    return this;
+  }
+
+  static encode(commands: SVGCommand[]) {
+    return encodeSVGPath(commands);
+      }
+
+  static parse(path: string) {
+    const parser = new SVGPathDataParser();
+    const commands: SVGCommand[] = [];
+    parser.parse(path, commands);
+    parser.finish(commands);
+    return commands;
+  }
+
+  static readonly CLOSE_PATH: 1 = 1;
+  static readonly MOVE_TO: 2 = 2;
+  static readonly HORIZ_LINE_TO: 4 = 4;
+  static readonly VERT_LINE_TO: 8 = 8;
+  static readonly LINE_TO: 16 = 16;
+  static readonly CURVE_TO: 32 = 32;
+  static readonly SMOOTH_CURVE_TO: 64 = 64;
+  static readonly QUAD_TO: 128 = 128;
+  static readonly SMOOTH_QUAD_TO: 256 = 256;
+  static readonly ARC: 512 = 512;
+  static readonly LINE_COMMANDS = SVGPathData.LINE_TO | SVGPathData.HORIZ_LINE_TO | SVGPathData.VERT_LINE_TO;
+  static readonly DRAWING_COMMANDS = SVGPathData.HORIZ_LINE_TO | SVGPathData.VERT_LINE_TO | SVGPathData.LINE_TO |
+  SVGPathData.CURVE_TO | SVGPathData.SMOOTH_CURVE_TO | SVGPathData.QUAD_TO |
+  SVGPathData.SMOOTH_QUAD_TO | SVGPathData.ARC;
+}
+
+export const COMMAND_ARG_COUNTS = {
+    [SVGPathData.MOVE_TO]: 2,
+    [SVGPathData.LINE_TO]: 2,
+    [SVGPathData.HORIZ_LINE_TO]: 1,
+    [SVGPathData.VERT_LINE_TO]: 1,
+    [SVGPathData.CLOSE_PATH]: 0,
+    [SVGPathData.QUAD_TO]: 4,
+    [SVGPathData.SMOOTH_QUAD_TO]: 2,
+    [SVGPathData.CURVE_TO]: 6,
+    [SVGPathData.SMOOTH_CURVE_TO]: 4,
+    [SVGPathData.ARC]: 7,
+};
+
+export {encodeSVGPath} from "./SVGPathDataEncoder";
+export {SVGPathDataParser} from "./SVGPathDataParser";
+export {SVGPathDataTransformer} from "./SVGPathDataTransformer";

package/templates/dev/template_admin/tools/iconfont/node_modules/svgicons2svgfont/node_modules/svg-pathdata/src/SVGPathDataEncoder.ts

@@ -0,0 +1,62 @@
+import { SVGPathData } from "./SVGPathData";
+import { SVGCommand } from "./types";
+
+// Encode SVG PathData
+// http://www.w3.org/TR/SVG/paths.html#PathDataBNF
+
+// Private consts : Char groups
+const WSP = " ";
+
+export function encodeSVGPath(commands: SVGCommand | SVGCommand[]) {
+  let str = "";
+
+  if (!Array.isArray(commands)) {
+    commands = [commands];
+  }
+  for (let i = 0; i < commands.length; i++) {
+    const command = commands[i];
+    if (command.type === SVGPathData.CLOSE_PATH) {
+      str += "z";
+    } else if (command.type === SVGPathData.HORIZ_LINE_TO) {
+      str += (command.relative ? "h" : "H") +
+        command.x;
+    } else if (command.type === SVGPathData.VERT_LINE_TO) {
+      str += (command.relative ? "v" : "V") +
+        command.y;
+    } else if (command.type === SVGPathData.MOVE_TO) {
+      str += (command.relative ? "m" : "M") +
+        command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.LINE_TO) {
+      str += (command.relative ? "l" : "L") +
+        command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.CURVE_TO) {
+      str += (command.relative ? "c" : "C") +
+        command.x1 + WSP + command.y1 +
+        WSP + command.x2 + WSP + command.y2 +
+        WSP + command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.SMOOTH_CURVE_TO) {
+      str += (command.relative ? "s" : "S") +
+        command.x2 + WSP + command.y2 +
+        WSP + command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.QUAD_TO) {
+      str += (command.relative ? "q" : "Q") +
+        command.x1 + WSP + command.y1 +
+        WSP + command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.SMOOTH_QUAD_TO) {
+      str += (command.relative ? "t" : "T") +
+        command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.ARC) {
+      str += (command.relative ? "a" : "A") +
+        command.rX + WSP + command.rY +
+        WSP + command.xRot +
+        WSP + (+command.lArcFlag) + WSP + (+command.sweepFlag) +
+        WSP + command.x + WSP + command.y;
+    } else {
+      // Unknown command
+      throw new Error(
+        `Unexpected command type "${ (command as any).type}" at index ${i}.`);
+    }
+  }
+
+  return str;
+}

package/templates/dev/template_admin/tools/iconfont/node_modules/svgicons2svgfont/node_modules/svg-pathdata/src/SVGPathDataParser.ts

@@ -0,0 +1,290 @@
+// Parse SVG PathData
+// http://www.w3.org/TR/SVG/paths.html#PathDataBNF
+import { COMMAND_ARG_COUNTS, SVGPathData } from "./SVGPathData";
+import { TransformableSVG } from "./TransformableSVG";
+import { SVGCommand, TransformFunction } from "./types";
+// Private consts : Char groups
+const isWhiteSpace = (c: string) =>
+  " " === c || "\t" === c || "\r" === c || "\n" === c;
+const isDigit = (c: string) =>
+  "0".charCodeAt(0) <= c.charCodeAt(0) && c.charCodeAt(0) <= "9".charCodeAt(0);
+const COMMANDS = "mMzZlLhHvVcCsSqQtTaA";
+
+export class SVGPathDataParser extends TransformableSVG {
+  private curNumber: string = "";
+  private curCommandType: SVGCommand["type"] | -1 = -1;
+  private curCommandRelative = false;
+  private canParseCommandOrComma = true;
+  private curNumberHasExp = false;
+  private curNumberHasExpDigits = false;
+  private curNumberHasDecimal = false;
+  private curArgs: number[] = [];
+
+  constructor() {
+    super();
+  }
+
+  finish(commands: SVGCommand[] = []) {
+    this.parse(" ", commands);
+    // Adding residual command
+    if (0 !== this.curArgs.length || !this.canParseCommandOrComma) {
+      throw new SyntaxError("Unterminated command at the path end.");
+    }
+    return commands;
+  }
+
+  parse(str: string, commands: SVGCommand[] = []) {
+    const finishCommand = (command: SVGCommand) => {
+      commands.push(command);
+      this.curArgs.length = 0;
+      this.canParseCommandOrComma = true;
+    };
+
+    for (let i = 0; i < str.length; i++) {
+      const c = str[i];
+      // White spaces parsing
+      const isAArcFlag = this.curCommandType === SVGPathData.ARC &&
+        (this.curArgs.length === 3 || this.curArgs.length === 4) &&
+        this.curNumber.length === 1 &&
+        (this.curNumber === "0" || this.curNumber === "1");
+      const isEndingDigit = isDigit(c) && (
+        (this.curNumber === "0" && c === "0") ||
+        isAArcFlag
+      );
+
+      if (
+        isDigit(c) &&
+        !isEndingDigit
+      ) {
+        this.curNumber += c;
+        this.curNumberHasExpDigits = this.curNumberHasExp;
+        continue;
+      }
+      if ("e" === c || "E" === c) {
+        this.curNumber += c;
+        this.curNumberHasExp = true;
+        continue;
+      }
+      if (
+        ("-" === c || "+" === c) &&
+        this.curNumberHasExp &&
+        !this.curNumberHasExpDigits
+      ) {
+        this.curNumber += c;
+        continue;
+      }
+      // if we already have a ".", it means we are starting a new number
+      if ("." === c && !this.curNumberHasExp && !this.curNumberHasDecimal && !isAArcFlag) {
+        this.curNumber += c;
+        this.curNumberHasDecimal = true;
+        continue;
+      }
+
+      // New number
+      if (this.curNumber && -1 !== this.curCommandType) {
+        const val = Number(this.curNumber);
+        if (isNaN(val)) {
+          throw new SyntaxError(`Invalid number ending at ${i}`);
+        }
+        if (this.curCommandType === SVGPathData.ARC) {
+          if (0 === this.curArgs.length || 1 === this.curArgs.length) {
+            if (0 > val) {
+              throw new SyntaxError(
+                `Expected positive number, got "${val}" at index "${i}"`,
+              );
+            }
+          } else if (3 === this.curArgs.length || 4 === this.curArgs.length) {
+            if ("0" !== this.curNumber && "1" !== this.curNumber) {
+              throw new SyntaxError(
+                `Expected a flag, got "${this.curNumber}" at index "${i}"`,
+              );
+            }
+          }
+        }
+        this.curArgs.push(val);
+        if (this.curArgs.length === COMMAND_ARG_COUNTS[this.curCommandType]) {
+          if (SVGPathData.HORIZ_LINE_TO === this.curCommandType) {
+            finishCommand({
+              type: SVGPathData.HORIZ_LINE_TO,
+              relative: this.curCommandRelative,
+              x: val,
+            });
+          } else if (SVGPathData.VERT_LINE_TO === this.curCommandType) {
+            finishCommand({
+              type: SVGPathData.VERT_LINE_TO,
+              relative: this.curCommandRelative,
+              y: val,
+            });
+            // Move to / line to / smooth quadratic curve to commands (x, y)
+          } else if (
+            this.curCommandType === SVGPathData.MOVE_TO ||
+            this.curCommandType === SVGPathData.LINE_TO ||
+            this.curCommandType === SVGPathData.SMOOTH_QUAD_TO
+          ) {
+            finishCommand({
+              type: this.curCommandType,
+              relative: this.curCommandRelative,
+              x: this.curArgs[0],
+              y: this.curArgs[1],
+            } as SVGCommand);
+            // Switch to line to state
+            if (SVGPathData.MOVE_TO === this.curCommandType) {
+              this.curCommandType = SVGPathData.LINE_TO;
+            }
+          } else if (this.curCommandType === SVGPathData.CURVE_TO) {
+            finishCommand({
+              type: SVGPathData.CURVE_TO,
+              relative: this.curCommandRelative,
+              x1: this.curArgs[0],
+              y1: this.curArgs[1],
+              x2: this.curArgs[2],
+              y2: this.curArgs[3],
+              x: this.curArgs[4],
+              y: this.curArgs[5],
+            });
+          } else if (this.curCommandType === SVGPathData.SMOOTH_CURVE_TO) {
+            finishCommand({
+              type: SVGPathData.SMOOTH_CURVE_TO,
+              relative: this.curCommandRelative,
+              x2: this.curArgs[0],
+              y2: this.curArgs[1],
+              x: this.curArgs[2],
+              y: this.curArgs[3],
+            });
+          } else if (this.curCommandType === SVGPathData.QUAD_TO) {
+            finishCommand({
+              type: SVGPathData.QUAD_TO,
+              relative: this.curCommandRelative,
+              x1: this.curArgs[0],
+              y1: this.curArgs[1],
+              x: this.curArgs[2],
+              y: this.curArgs[3],
+            });
+          } else if (this.curCommandType === SVGPathData.ARC) {
+            finishCommand({
+              type: SVGPathData.ARC,
+              relative: this.curCommandRelative,
+              rX: this.curArgs[0],
+              rY: this.curArgs[1],
+              xRot: this.curArgs[2],
+              lArcFlag: this.curArgs[3] as 0 | 1,
+              sweepFlag: this.curArgs[4] as 0 | 1,
+              x: this.curArgs[5],
+              y: this.curArgs[6],
+            });
+          }
+        }
+        this.curNumber = "";
+        this.curNumberHasExpDigits = false;
+        this.curNumberHasExp = false;
+        this.curNumberHasDecimal = false;
+        this.canParseCommandOrComma = true;
+      }
+      // Continue if a white space or a comma was detected
+      if (isWhiteSpace(c)) {
+        continue;
+      }
+      if ("," === c && this.canParseCommandOrComma) {
+        // L 0,0, H is not valid:
+        this.canParseCommandOrComma = false;
+        continue;
+      }
+      // if a sign is detected, then parse the new number
+      if ("+" === c || "-" === c || "." === c) {
+        this.curNumber = c;
+        this.curNumberHasDecimal = "." === c;
+        continue;
+      }
+      // if a 0 is detected, then parse the new number
+      if (isEndingDigit) {
+        this.curNumber = c;
+        this.curNumberHasDecimal = false;
+        continue;
+      }
+
+      // Adding residual command
+      if (0 !== this.curArgs.length) {
+        throw new SyntaxError(`Unterminated command at index ${i}.`);
+      }
+      if (!this.canParseCommandOrComma) {
+        throw new SyntaxError(
+          `Unexpected character "${c}" at index ${i}. Command cannot follow comma`,
+        );
+      }
+      this.canParseCommandOrComma = false;
+      // Detecting the next command
+      if ("z" === c || "Z" === c) {
+        commands.push({
+          type: SVGPathData.CLOSE_PATH,
+        });
+        this.canParseCommandOrComma = true;
+        this.curCommandType = -1;
+        continue;
+        // Horizontal move to command
+      } else if ("h" === c || "H" === c) {
+        this.curCommandType = SVGPathData.HORIZ_LINE_TO;
+        this.curCommandRelative = "h" === c;
+        // Vertical move to command
+      } else if ("v" === c || "V" === c) {
+        this.curCommandType = SVGPathData.VERT_LINE_TO;
+        this.curCommandRelative = "v" === c;
+        // Move to command
+      } else if ("m" === c || "M" === c) {
+        this.curCommandType = SVGPathData.MOVE_TO;
+        this.curCommandRelative = "m" === c;
+        // Line to command
+      } else if ("l" === c || "L" === c) {
+        this.curCommandType = SVGPathData.LINE_TO;
+        this.curCommandRelative = "l" === c;
+        // Curve to command
+      } else if ("c" === c || "C" === c) {
+        this.curCommandType = SVGPathData.CURVE_TO;
+        this.curCommandRelative = "c" === c;
+        // Smooth curve to command
+      } else if ("s" === c || "S" === c) {
+        this.curCommandType = SVGPathData.SMOOTH_CURVE_TO;
+        this.curCommandRelative = "s" === c;
+        // Quadratic bezier curve to command
+      } else if ("q" === c || "Q" === c) {
+        this.curCommandType = SVGPathData.QUAD_TO;
+        this.curCommandRelative = "q" === c;
+        // Smooth quadratic bezier curve to command
+      } else if ("t" === c || "T" === c) {
+        this.curCommandType = SVGPathData.SMOOTH_QUAD_TO;
+        this.curCommandRelative = "t" === c;
+        // Elliptic arc command
+      } else if ("a" === c || "A" === c) {
+        this.curCommandType = SVGPathData.ARC;
+        this.curCommandRelative = "a" === c;
+      } else {
+        throw new SyntaxError(`Unexpected character "${c}" at index ${i}.`);
+      }
+    }
+    return commands;
+  }
+  /**
+   * Return a wrapper around this parser which applies the transformation on parsed commands.
+   */
+  transform(transform: TransformFunction) {
+    const result = Object.create(this, {
+      parse: {
+        value(chunk: string, commands: SVGCommand[] = []) {
+          const parsedCommands = Object.getPrototypeOf(this).parse.call(
+            this,
+            chunk,
+          );
+          for (const c of parsedCommands) {
+            const cT = transform(c);
+            if (Array.isArray(cT)) {
+              commands.push(...cT);
+            } else {
+              commands.push(cT);
+            }
+          }
+          return commands;
+        },
+      },
+    });
+    return result as this;
+  }
+}