kn-cli 1.0.26 → 1.0.28

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

@@ -1,90 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,290 +0,0 @@
-// 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;
-  }
-}