{"version":3,"file":"index.mjs","sources":["../src/constants.ts","../src/lexer/tokens.ts","../src/lexer/rules.ts","../src/lexer/index.ts","../src/tree.ts","../src/syntax/rules.ts","../src/syntax/map-tokens.ts","../src/syntax/drill.ts","../src/syntax/match-syntax.ts","../src/syntax/macro.ts","../src/syntax/gerber.ts","../src/syntax/index.ts","../src/parser.ts"],"sourcesContent":["// common constants\n\n// filetype constants\nexport const GERBER = 'gerber'\nexport const DRILL = 'drill'\n\n// units constants\nexport const MM = 'mm'\nexport const IN = 'in'\n\n// format constants\nexport const LEADING = 'leading'\nexport const TRAILING = 'trailing'\nexport const ABSOLUTE = 'absolute'\nexport const INCREMENTAL = 'incremental'\n\n// tool constants\nexport const CIRCLE = 'circle'\nexport const RECTANGLE = 'rectangle'\nexport const OBROUND = 'obround'\nexport const POLYGON = 'polygon'\nexport const MACRO_SHAPE = 'macroShape'\n\n// macro primitive codes\nexport const MACRO_CIRCLE = '1'\nexport const MACRO_VECTOR_LINE = '20'\nexport const MACRO_CENTER_LINE = '21'\nexport const MACRO_OUTLINE = '4'\nexport const MACRO_POLYGON = '5'\nexport const MACRO_MOIRE = '6'\nexport const MACRO_THERMAL = '7'\n\n// drawing constants\nexport const SHAPE = 'shape'\nexport const MOVE = 'move'\nexport const SEGMENT = 'segment'\nexport const SLOT = 'slot'\n\n// interpolation / routing constants\nexport const LINE = 'line'\nexport const CW_ARC = 'cwArc'\nexport const CCW_ARC = 'ccwArc'\n\n// quadrant mode\nexport const SINGLE = 'single'\nexport const MULTI = 'multi'\n\n// load polarity\nexport const DARK = 'dark'\nexport const CLEAR = 'clear'\n","import {Token as MooToken} from 'moo'\n\n/**\n * T-code token type\n *\n * @category Lexer\n */\nexport const T_CODE = 'T_CODE'\n\n/**\n * G-code token type\n *\n * @category Lexer\n */\nexport const G_CODE = 'G_CODE'\n\n/**\n * M-code token type\n *\n * @category Lexer\n */\nexport const M_CODE = 'M_CODE'\n\n/**\n * D-code token type\n *\n * @category Lexer\n */\nexport const D_CODE = 'D_CODE'\n\n/**\n * Asterisk token type\n *\n * @category Lexer\n */\nexport const ASTERISK = 'ASTERISK'\n\n/**\n * Percent sign token type\n *\n * @category Lexer\n */\nexport const PERCENT = 'PERCENT'\n\n/**\n * Equals sign token type\n *\n * @category Lexer\n */\nexport const EQUALS = 'EQUALS'\n\n/**\n * Comma token type\n *\n * @category Lexer\n */\nexport const COMMA = 'COMMA'\n\n/**\n * Arithmatic operator token type\n *\n * @category Lexer\n */\nexport const OPERATOR = 'OPERATOR'\n\n/**\n * Gerber format specification token type\n *\n * @category Lexer\n */\nexport const GERBER_FORMAT = 'GERBER_FORMAT'\n\n/**\n * Gerber units specification token type\n *\n * @category Lexer\n */\nexport const GERBER_UNITS = 'GERBER_UNITS'\n\n/**\n * Gerber tool macro token type\n *\n * @category Lexer\n */\nexport const GERBER_TOOL_MACRO = 'GERBER_TOOL_MACRO'\n\n/**\n * Gerber tool definition token type\n *\n * @category Lexer\n */\nexport const GERBER_TOOL_DEF = 'GERBER_TOOL_DEF'\n\n/**\n * Gerber load polarity token type\n *\n * @category Lexer\n */\nexport const GERBER_LOAD_POLARITY = 'GERBER_LOAD_POLARITY'\n\n/**\n * Gerber step repear token type\n *\n * @category Lexer\n */\nexport const GERBER_STEP_REPEAT = 'GERBER_STEP_REPEAT'\n\n/**\n * Gerber macro variable token type\n *\n * @category Lexer\n */\nexport const GERBER_MACRO_VARIABLE = 'GERBER_MACRO_VARIABLE'\n\n/**\n * Semicolor token type\n *\n * @category Lexer\n */\nexport const SEMICOLON = 'SEMICOLON'\n\n/**\n * Drill file units token type\n *\n * @category Lexer\n */\nexport const DRILL_UNITS = 'DRILL_UNITS'\n\n/**\n * Drill zero-inclusion token type\n *\n * @category Lexer\n */\nexport const DRILL_ZERO_INCLUSION = 'DRILL_ZERO_INCLUSION'\n\n/**\n * Coordinate axis character token type\n *\n * @category Lexer\n */\nexport const COORD_CHAR = 'COORD_CHAR'\n\n/**\n * Number token type\n *\n * @category Lexer\n */\nexport const NUMBER = 'NUMBER'\n\n/**\n * Word token type\n *\n * @category Lexer\n */\nexport const WORD = 'WORD'\n\n/**\n * Whitespace token type\n *\n * @category Lexer\n */\nexport const WHITESPACE = 'WHITESPACE'\n\n/**\n * Newline token type\n *\n * @category Lexer\n */\nexport const NEWLINE = 'NEWLINE'\n\n/**\n * Catchall token type\n *\n * @category Lexer\n */\nexport const CATCHALL = 'CATCHALL'\n\n/**\n * Error token type\n *\n * @category Lexer\n */\nexport const ERROR = 'ERROR'\n\n/**\n * Union of all available token types\n *\n * @category Lexer\n */\nexport type TokenType =\n  | typeof T_CODE\n  | typeof G_CODE\n  | typeof M_CODE\n  | typeof D_CODE\n  | typeof ASTERISK\n  | typeof PERCENT\n  | typeof EQUALS\n  | typeof COMMA\n  | typeof OPERATOR\n  | typeof GERBER_FORMAT\n  | typeof GERBER_UNITS\n  | typeof GERBER_TOOL_MACRO\n  | typeof GERBER_TOOL_DEF\n  | typeof GERBER_LOAD_POLARITY\n  | typeof GERBER_STEP_REPEAT\n  | typeof GERBER_MACRO_VARIABLE\n  | typeof SEMICOLON\n  | typeof DRILL_UNITS\n  | typeof DRILL_ZERO_INCLUSION\n  | typeof COORD_CHAR\n  | typeof NUMBER\n  | typeof WORD\n  | typeof WHITESPACE\n  | typeof NEWLINE\n  | typeof CATCHALL\n  | typeof ERROR\n\n/**\n * {@linkcode Lexer} token\n *\n * @category Lexer\n */\nexport interface Token extends MooToken {\n  /** Token identifier */\n  type: TokenType\n}\n","import Moo from 'moo'\nimport * as Tokens from './tokens'\n\nexport type Rules = {\n  [t in Tokens.TokenType]:\n    | RegExp\n    | string\n    | Array<string>\n    | Moo.Rule\n    | Array<Moo.Rule>\n}\n\nconst RE_STRIP_LEADING_ZEROS = /^0*/\n\nconst stripLeadingZeros = (text: string): string => {\n  return text.replace(RE_STRIP_LEADING_ZEROS, '')\n}\n\nconst getCodeValue = (text: string): string => {\n  return stripLeadingZeros(text.slice(1)) || '0'\n}\n\nexport const rules: Rules = {\n  [Tokens.T_CODE]: {\n    match: /T\\d+/,\n    value: getCodeValue,\n  },\n  [Tokens.G_CODE]: {\n    match: /G\\d+/,\n    value: getCodeValue,\n  },\n  [Tokens.M_CODE]: {\n    match: /M\\d+/,\n    value: getCodeValue,\n  },\n  [Tokens.D_CODE]: {\n    match: /D\\d+/,\n    value: getCodeValue,\n  },\n  [Tokens.ASTERISK]: '*',\n  [Tokens.PERCENT]: '%',\n  [Tokens.EQUALS]: '=',\n  [Tokens.GERBER_FORMAT]: {\n    match: /FS[LTDAI]+/,\n    value: (text: string): string => text.slice(2),\n  },\n  [Tokens.GERBER_UNITS]: {\n    match: /MO(?:IN|MM)/,\n    value: (text: string): string => text.slice(2),\n  },\n  [Tokens.GERBER_TOOL_MACRO]: {\n    // \"-\" in a tool name is illegal, but some gerber writers misbehave\n    // https://github.com/mcous/gerber-parser/pull/13\n    match: /AM[a-zA-Z_.$][\\w.-]*/,\n    value: (text: string): string => text.slice(2),\n  },\n  [Tokens.GERBER_TOOL_DEF]: {\n    match: /ADD\\d+[a-zA-Z_.$][\\w.-]*/,\n    value: (text: string): string => stripLeadingZeros(text.slice(3)),\n  },\n  [Tokens.GERBER_LOAD_POLARITY]: {\n    match: /LP[DC]/,\n    value: (text: string): string => text.slice(2),\n  },\n  [Tokens.GERBER_STEP_REPEAT]: 'SR',\n  [Tokens.GERBER_MACRO_VARIABLE]: /\\$\\d+/,\n  [Tokens.SEMICOLON]: ';',\n  [Tokens.DRILL_UNITS]: /^(?:METRIC|INCH)/,\n  [Tokens.DRILL_ZERO_INCLUSION]: {\n    match: /,(?:TZ|LZ)/,\n    value: (text: string): string => text.slice(1),\n  },\n  [Tokens.COORD_CHAR]: /[XYIJACFSBHZN]/,\n  [Tokens.NUMBER]: /(?:[+-])?[\\d.]+/,\n  [Tokens.OPERATOR]: ['x', '/', '+', '-', '(', ')'],\n  [Tokens.COMMA]: ',',\n  [Tokens.WORD]: /[a-zA-Z]+/,\n  [Tokens.WHITESPACE]: /[ \\t]+/,\n  [Tokens.NEWLINE]: {\n    match: /\\r?\\n/,\n    lineBreaks: true,\n  },\n  [Tokens.CATCHALL]: /[\\S]/,\n  [Tokens.ERROR]: Moo.error,\n}\n","// gerber and drill file lexer + tokenizer\nimport Moo from 'moo'\nimport {Token} from './tokens'\nimport {rules} from './rules'\n\nexport type LexerState = Moo.LexerState\n\nexport * from './tokens'\n\n/**\n * {@linkcode Lexer} factory\n *\n * @example\n * ```ts\n * import {createLexer} from '@tracespace/parser'\n *\n * const lexer = createLexer()\n *\n * lexer.reset('G04 gerber string*\\nM02*\\n')\n *\n * Array.from(lexer).forEach(token => {\n *   console.log(`${token.type}: ${token.value}`)\n * })\n * ```\n *\n * @category Lexer\n */\nexport function createLexer(): Lexer {\n  return Moo.compile(rules) as Lexer\n}\n\n/**\n * The lexing module of the parser. The Lexer is generated by\n * {@link https://github.com/no-context/moo | Moo}, which determines its API.\n *\n * @category Lexer\n */\nexport interface Lexer extends Moo.Lexer {\n  /** Cursor position in the current chunk */\n  index?: number\n  /** Retrieve the next token from the chunk if available */\n  next(): Token | undefined\n  /** The Lexer may be treated as an iterator to get tokens */\n  [Symbol.iterator](): Iterator<Token>\n}\n","import {Position} from 'unist'\n\nimport * as Types from './types'\n\n/**\n * {@linkcode Root} node type\n *\n * @category Node\n */\nexport const ROOT = 'root'\n\n/**\n * {@linkcode Comment} node type\n *\n * @category Node\n */\nexport const COMMENT = 'comment'\n\n/**\n * {@linkcode Done} node type\n *\n * @category Node\n */\nexport const DONE = 'done'\n\n/**\n * {@linkcode Units} node type\n *\n * @category Node\n */\nexport const UNITS = 'units'\n\n/**\n * {@linkcode CoordinateFormat} node type\n *\n * @category Node\n */\nexport const COORDINATE_FORMAT = 'coordinateFormat'\n\n/**\n * {@linkcode ToolDefinition} node type\n *\n * @category Node\n */\nexport const TOOL_DEFINITION = 'toolDefinition'\n\n/**\n * {@linkcode ToolMacro} node type\n *\n * @category Node\n */\nexport const TOOL_MACRO = 'toolMacro'\n\n/**\n * {@linkcode ToolChange} node type\n *\n * @category Node\n */\nexport const TOOL_CHANGE = 'toolChange'\n\n/**\n * {@linkcode LoadPolarity} node type\n *\n * @category Node\n */\nexport const LOAD_POLARITY = 'loadPolarity'\n\n/**\n * {@linkcode StepRepeat} node type\n *\n * @category Node\n */\nexport const STEP_REPEAT = 'stepRepeat'\n\n/**\n * {@linkcode Graphic} node type\n *\n * @category Node\n */\nexport const GRAPHIC = 'graphic'\n\n/**\n * {@linkcode InterpolateMode} node type\n *\n * @category Node\n */\nexport const INTERPOLATE_MODE = 'interpolateMode'\n\n/**\n * {@linkcode RegionMode} node type\n *\n * @category Node\n */\nexport const REGION_MODE = 'regionMode'\n\n/**\n * {@linkcode QuadrantMode} node type\n *\n * @category Node\n */\nexport const QUADRANT_MODE = 'quadrantMode'\n\n/**\n * {@linkcode Unimplemented} node type\n *\n * @category Node\n */\nexport const UNIMPLEMENTED = 'unimplemented'\n\n/**\n * {@linkcode MacroComment} node type\n *\n * @category Macro\n */\nexport const MACRO_COMMENT = 'macroComment'\n\n/**\n * {@linkcode MacroVariable} node type\n *\n * @category Macro\n */\nexport const MACRO_VARIABLE = 'macroVariable'\n\n/**\n * {@linkcode MacroPrimitive} node type\n *\n * @category Macro\n */\nexport const MACRO_PRIMITIVE = 'macroPrimitive'\n\ninterface BaseNode {\n  type: string\n  /** Location in the source file the node was parsed from */\n  position?: Position\n}\n\ninterface BaseParent extends BaseNode {\n  children: Array<BaseNode>\n}\n\n/**\n * Syntax tree node\n *\n * @category Node\n */\nexport type Node = Root | ChildNode\n\n/**\n * Child of the tree's {@linkcode Root} node\n *\n * @category Node\n */\nexport type ChildNode =\n  | Comment\n  | Done\n  | Units\n  | CoordinateFormat\n  | ToolDefinition\n  | ToolMacro\n  | ToolChange\n  | InterpolateMode\n  | RegionMode\n  | QuadrantMode\n  | LoadPolarity\n  | StepRepeat\n  | Graphic\n  | Unimplemented\n\n/**\n * Child of a {@linkcode ToolMacro} node\n *\n * @category Macro\n */\nexport type MacroBlock = MacroComment | MacroVariable | MacroPrimitive\n\n/**\n * Root node of the syntax tree, identifying the filetype and whether or not\n * the entire file seems to have been read. Filetype, if known, will be\n * either {@linkcode GERBER | gerber} or {@linkcode DRILL | drill}.\n *\n * If `filetype` is `null` or `done` is `false`, this may be a sign that\n *\n * 1. the parser has not finished parsing the file or\n * 2. the file is invalid and/or not a Gerber or drill file.\n *\n * @category Node\n */\nexport interface Root extends BaseParent {\n  /** Node type */\n  type: typeof ROOT\n  /** The parsed file's type (Gerber or NC drill), if known */\n  filetype: Types.Filetype | null\n  /** Whether the parser has encountered a \"done\" command in the file */\n  done: boolean\n  /** Parse results */\n  children: ChildNode[]\n}\n\n/**\n * Node representing a comment in the file. Usually, comment nodes can be\n * ignored, but in NC drill files, they may contain important format\n * specifications that are not able to be expressed in the file itself.\n *\n *  @category Node\n */\nexport interface Comment extends BaseNode {\n  /** Node type */\n  type: typeof COMMENT\n  /** Contents of the comment as a string */\n  comment: string\n}\n\n/**\n * Node representing a done command. This represents an `M02` or `M00` command\n * in a Gerber file or an `M00` or `M30` in an NC drill file. Its presence in a\n * tree means the full source file was parsed.\n *\n * @category Node\n */\nexport interface Done extends BaseNode {\n  /** Node type */\n  type: typeof DONE\n}\n\n/**\n * A `Units` node specifies the units used for the file. Units may be\n * {@linkcode IN | in} or {@linkcode MM | mm}.\n *\n * @category Node\n */\nexport interface Units extends BaseNode {\n  /** Node type */\n  type: typeof UNITS\n  /** Inches or millimeters */\n  units: Types.UnitsType\n}\n\n/**\n * A `CoordinateFormat` node specifies the format of coordinate value strings.\n *\n * In Gerber and drill files, coordinates are (almost always) specified as\n * strings of digits without decimal points. `format` is a tuple where the\n * first element is the number of integer places in the string and the second\n * is the number of decimal places. Leading or trailing zeros may also be\n * omitted from the coordinate strings.\n *\n * For example, with `format` set to `[2, 4]`, some (intermediate) coordinate\n * strings could be:\n *\n * - `0.012` > `000120`\n * - `3.45` > `034500`\n * - `67` > `670000`\n *\n * With those same numbers, either {@linkcode LEADING | leading} or\n * {@linkcode TRAILING | trailing} zeros may be omitted depending on the\n * `zeroSuppression` setting:\n *\n * - `0.012` > `000120` > leading omitted: `120`, trailing omitted: `00012`\n * - `3.45` > `024500` > leading omitted: `24500`, trailing omitted: `0245`\n * - `67` > `670000` > leading omitted: `670000`, trailing omitted: `67`\n *\n * Some important things to keep in mind when processing coordinate strings\n * according to the `CoordinateFormat` node:\n *\n * - `format`, `zeroSuppression`, and/or `mode` could be left unspecified\n *     - In this case, `format` and `zeroSuppression` should be assumed or\n *       inferred, if possible\n *     - It's very safe to assume `mode` is always {@linkcode ABSOLUTE | absolute};\n *       {@linkcode INCREMENTAL | incremental} mode is deprecated and very rare\n * - Just because `zeroSuppression` is set doesn't mean zeros are dropped\n *     - It's common to see Gerber writers keep all zeros to ensure there is no\n *       ambiguity, but `zeroSuppression` still needs to be set to _something_\n * - A Gerber or NC drill file may choose to include decimal points! This is\n *   not necessarily \"in spec\", but it is unambiguous and easy to parse\n *\n * @category Node\n */\nexport interface CoordinateFormat extends BaseNode {\n  /** Node type */\n  type: typeof COORDINATE_FORMAT\n  /** Integer/decimal format setting, if known */\n  format: Types.Format | null\n  /** Zero suppression setting, if known */\n  zeroSuppression: Types.ZeroSuppression | null\n  /** Absolute or incremental coordinate system, if known */\n  mode: Types.Mode | null\n}\n\n/**\n * A `ToolDefinition` node defines a \"tool\" that may be used to either create a\n * shape (\"pad\" or \"drill hit\") or a stroke (\"trace\" or \"route\") in a later\n * graphic command.\n *\n * A tool shape may be one of:\n *\n * - {@linkcode Circle} - A circle defined by a diameter\n * - {@linkcode Rectangle} - A rectangle defined by sizes in the x and y axis\n * - {@linkcode Obround} - A \"pill\" rectangle, with a border-radius equal to half of its shorter side\n * - {@linkcode Polygon} - A regular polygon defined by its diameter, number of vertices, and rotation\n * - {@linkcode MacroShape} - A shape defined by a previous {@linkcode ToolMacro}\n *\n * A tool may have a hole in its center; the `hole`, if not `null`, may be a:\n *\n * - {@linkcode Circle}\n * - {@linkcode Rectangle} (deprecated by the Gerber specification)\n *\n * Only `Circle` or `Rectangle` tools without a `hole` may create strokes.\n * `MacroShape` tools may not have a `hole` defined.\n *\n * @category Node\n */\nexport interface ToolDefinition extends BaseNode {\n  /** Node type */\n  type: typeof TOOL_DEFINITION\n  /** Unique tool identifier */\n  code: string\n  /** Tool shape */\n  shape: Types.ToolShape\n  /** Hole shape, if applicable */\n  hole: Types.HoleShape | null\n}\n\n/**\n * A `ToolMacro` node describes a complex shape in a Gerber file that can use a\n * variety of \"primitives\", simple arithmetic, and differing polarities to lay\n * out an image that will later be repeated.\n *\n * See the {@link https://www.ucamco.com/gerber | Gerber file specification}\n * for an in-depth description of how macros function.\n *\n * @category Node\n */\nexport interface ToolMacro extends BaseNode {\n  /** Node type */\n  type: typeof TOOL_MACRO\n  /** Unique macro identifier */\n  name: string\n  /** Macro definition blocks */\n  children: MacroBlock[]\n}\n\n/**\n * A `MacroComment` represents a comment in a macro and can be safely ignored\n *\n * @category Macro\n */\nexport interface MacroComment extends BaseNode {\n  /** Node type */\n  type: typeof MACRO_COMMENT\n  /** Comment string */\n  comment: string\n}\n\n/**\n * A `MacroVariable` node assigns a value to the `name` variable in a macro,\n * where that value may be a number or an arithmetic expression.\n *\n * @category Macro\n */\nexport interface MacroVariable extends BaseNode {\n  /** Node type */\n  type: typeof MACRO_VARIABLE\n  /** Variable name */\n  name: string\n  /** Concrete value or expression to assign to variable */\n  value: Types.MacroValue\n}\n\n/**\n * A `MacroPrimitive` node describes a shape to add to the overall macro shape.\n *\n * @category Macro\n */\nexport interface MacroPrimitive extends BaseNode {\n  /** Node type */\n  type: typeof MACRO_PRIMITIVE\n  /** Primitive shape type */\n  code: Types.MacroPrimitiveCode | string\n  /** Shape modifier values or expressions */\n  modifiers: Types.MacroValue[]\n}\n\n/**\n * A `ToolChange` node sets the current active \"tool\". At a given point in the\n * file, the active tool determines the image that graphical operations produce.\n *\n * @category Node\n */\nexport interface ToolChange extends BaseNode {\n  /** Node type */\n  type: typeof TOOL_CHANGE\n  /** Tool identifier */\n  code: string\n}\n\n/**\n * A `LoadPolarity` node sets the current polarity to {@linkcode DARK | dark}\n * or {@linkcode CLEAR | clear}. Subsequent {@linkcode Graphic} operations\n * add to the overall image if the polarity is \"dark\", or remove from the image\n * if the polarity is \"clear\".\n *\n * @category Node\n */\nexport interface LoadPolarity extends BaseNode {\n  /** Node type */\n  type: typeof LOAD_POLARITY\n  /** Polarity */\n  polarity: Types.Polarity\n}\n\n/**\n * A `StepRepeat` node starts or ends a step repeat block.\n *\n * See the {@link https://www.ucamco.com/gerber | Gerber file specification}\n * for an in-depth description of step repeat blocks.\n *\n * @category Node\n */\nexport interface StepRepeat extends BaseNode {\n  /** Node type */\n  type: typeof STEP_REPEAT\n  /** Step repeat parameters */\n  stepRepeat: Types.StepRepeatParameters\n}\n\n/**\n * A `Graphic` node that represents an image being draw to the active layer.\n * The type of image \"drawn\" is dependent on the value of `graphic`:\n *\n * - {@linkcode SHAPE | shape} - the shape of the current tool is added to the\n *   image at `coordinates`\n * - {@linkcode MOVE | move} - the plotter is \"moved\" to `coordinates` **without\n *   drawing anything to the image**\n * - {@linkcode SEGMENT | segment} - the tool is \"stroked\" from the plotter's\n *   current location to `coordinates`\n *     - The path the tool takes is determined by the current {@linkcode IterpolateMode}\n *     - The segment may be a standalone path, or it may be a part of a region\n *       fill set by a {@linkcode RegionMode}\n *     - Only {@linkcode Circle} or {@linkcode Rectangle} tools may create\n *       standalone paths\n * - {@linkcode SLOT | slot} - a drill-file-specific graphic that creates a\n *   slot from `(coordinates.x1, coordinates.y1)` to `(coordinates.x2, coordinates.y2)`\n * - `null` - The graphic type was not explicitly specified in the source file\n *     - This is deprecated syntax in Gerber files, but if present the last\n *       used graphic type should be repeated\n *     - In a drill file, this means `shape` if in `drill` mode (default),\n *       `move` if in `move` mode, or `segment` if in a routing mode\n *\n * @category Node\n */\nexport interface Graphic extends BaseNode {\n  /** Node type */\n  type: typeof GRAPHIC\n  /** Graphical operation */\n  graphic: Types.GraphicType\n  /** Coordinates where the graphic will be applied */\n  coordinates: Types.Coordinates\n}\n\n/**\n * An `InterpolateMode` node is a command to define how subsequent `segment`\n * (or `null`, if you're processing a drill file) graphic nodes are rendered.\n * The `mode` may be one of:\n *\n * - {@linkcode LINE | line} - Draw a straight line segment\n * - {@linkcode CW_ARC | cwArc} - Draw a clockwise arc segment\n * - {@linkcode CCW_ARC | ccwArc} - Draw a counterclockwise arc segment\n * - {@linkcode MOVE | move } - (Drill file only) Move the current coordinate without drawing\n * - {@linkcode DRILL | drill} - (Drill file only) Draw a shape with the current tool\n *\n * @category Node\n */\nexport interface InterpolateMode extends BaseNode {\n  type: typeof INTERPOLATE_MODE\n  mode: Types.InterpolateModeType\n}\n\n/**\n * A `RegionMode` node is a command to treat subsequent graphics as part of a\n * region definition. Regions are typically used to describe things like\n * copper fills, and only occur in Gerber files. In region mode:\n *\n * - `segment` graphics define the edges of the region\n * - `move` graphics end the current region and start a new one\n * - Other grahpics are disallowed\n *\n * @category Node\n */\nexport interface RegionMode extends BaseNode {\n  type: typeof REGION_MODE\n  region: boolean\n}\n\n/**\n * A `QuadrantMode` node determines how subsequent arc segments are drawn.\n *\n * See the {@link https://www.ucamco.com/gerber | Gerber file specification}\n * for an in-depth description of arc plotting.\n *\n * @category Node\n */\nexport interface QuadrantMode extends BaseNode {\n  type: typeof QUADRANT_MODE\n  quadrant: Types.QuadrantModeType\n}\n\n/**\n * An `Unimplemented` node is a chunk that the parser recognizes as part of a\n * Gerber file, but that it doesn't know how to process. These Nodes may be\n * implemented in a future minor release of the parser and should be used with\n * caution.\n *\n * Most unimplemented nodes will either be deprecated commands or valid\n * commands in the {@link https://www.ucamco.com/gerber | Gerber specification}\n * that we don't yet support.\n *\n * @category Node\n */\nexport interface Unimplemented extends BaseNode {\n  /** Node type */\n  type: typeof UNIMPLEMENTED\n  /** String value of chunk */\n  value: string\n}\n","import {Token} from '../lexer'\n\nexport const SINGLE_TOKEN = 'TOKEN'\nexport const MIN_TO_MAX = 'MIN_TO_MAX'\n\nexport interface SingleTokenRule {\n  rule: typeof SINGLE_TOKEN\n  type: Token['type']\n  value: Token['value'] | RegExp | null | undefined\n  negate?: boolean\n}\n\nexport interface MinToMaxRule {\n  rule: typeof MIN_TO_MAX\n  min: number\n  max: number\n  match: Array<SingleTokenRule>\n}\n\nexport type TokenRule = SingleTokenRule | MinToMaxRule\n\nexport function token(\n  type: Token['type'],\n  value?: Token['value'] | RegExp\n): SingleTokenRule {\n  return {rule: SINGLE_TOKEN, type, value}\n}\n\nexport function notToken(\n  type: Token['type'],\n  value?: Token['value']\n): SingleTokenRule {\n  return {rule: SINGLE_TOKEN, type, value, negate: true}\n}\n\nexport function one(match: Array<SingleTokenRule>): MinToMaxRule {\n  return {rule: MIN_TO_MAX, min: 1, max: 1, match}\n}\n\nexport function zeroOrOne(match: Array<SingleTokenRule>): MinToMaxRule {\n  return {rule: MIN_TO_MAX, min: 0, max: 1, match}\n}\n\nexport function zeroOrMore(match: Array<SingleTokenRule>): MinToMaxRule {\n  return {rule: MIN_TO_MAX, min: 0, max: Infinity, match}\n}\n\nexport function oneOrMore(match: Array<SingleTokenRule>): MinToMaxRule {\n  return {rule: MIN_TO_MAX, min: 1, max: Infinity, match}\n}\n\nexport function minToMax(\n  min: number,\n  max: number,\n  match: Array<SingleTokenRule>\n): MinToMaxRule {\n  return {rule: MIN_TO_MAX, min, max, match}\n}\n","import {Position} from 'unist'\nimport {Token, NUMBER, COORD_CHAR, G_CODE, D_CODE} from '../lexer'\nimport {Coordinates, InterpolateModeType, GraphicType} from '../types'\nimport {SEGMENT, MOVE, SHAPE, LINE, CW_ARC, CCW_ARC, DRILL} from '../constants'\n\nexport function tokensToCoordinates(tokens: Array<Token>): Coordinates {\n  return tokens.reduce<Coordinates>((coords, token, i) => {\n    const prev = tokens[i - 1]\n\n    if (token.type === NUMBER && prev?.type === COORD_CHAR) {\n      coords[prev.value.toLowerCase()] = token.value\n    }\n\n    return coords\n  }, {})\n}\n\nexport function tokensToMode(tokens: Token[]): InterpolateModeType {\n  return tokens\n    .filter(t => t.type === G_CODE)\n    .reduce<InterpolateModeType>((m, t) => {\n      if (t.value === '0') return MOVE\n      if (t.value === '1') return LINE\n      if (t.value === '2') return CW_ARC\n      if (t.value === '3') return CCW_ARC\n      if (t.value === '5') return DRILL\n      return m\n    }, null)\n}\n\nexport function tokensToGraphic(tokens: Array<Token>): GraphicType {\n  return tokens\n    .filter(t => t.type === D_CODE)\n    .reduce<GraphicType>((g, t) => {\n      if (t.value === '1') return SEGMENT\n      if (t.value === '2') return MOVE\n      if (t.value === '3') return SHAPE\n      return g\n    }, null)\n}\n\nexport function tokensToString(tokens: Token[]): string {\n  return tokens\n    .map(t => t.value)\n    .join('')\n    .trim()\n}\n\nexport function tokensToPosition(\n  tokens: Token[],\n  options: Partial<{head: Token; length: number}> = {}\n): Position {\n  const head = options.head ?? tokens[0]\n  const tail = options.length\n    ? tokens[tokens.indexOf(head) + options.length - 1]\n    : tokens[tokens.length - 1]\n\n  return {\n    start: {line: head.line, column: head.col, offset: head.offset},\n    end: {line: tail.line, column: tail.col, offset: tail.offset},\n  }\n}\n","// drill file grammar\nimport * as Lexer from '../lexer'\nimport * as Tree from '../tree'\nimport * as Constants from '../constants'\nimport * as Types from '../types'\nimport {token, notToken, one, zeroOrOne, zeroOrMore, minToMax} from './rules'\nimport {SyntaxRule} from './types'\n\nimport {\n  tokensToCoordinates,\n  tokensToMode,\n  tokensToString,\n  tokensToPosition,\n} from './map-tokens'\n\nconst units: SyntaxRule = {\n  rules: [\n    one([\n      token(Lexer.DRILL_UNITS),\n      token(Lexer.M_CODE, '71'),\n      token(Lexer.M_CODE, '72'),\n    ]),\n    zeroOrMore([\n      token(Lexer.COMMA),\n      token(Lexer.DRILL_ZERO_INCLUSION),\n      token(Lexer.NUMBER, /^0{1,8}\\.0{1,8}$/),\n    ]),\n    token(Lexer.NEWLINE),\n  ],\n  createNodes: tokens => {\n    const units =\n      tokens[0].value === 'INCH' || tokens[0].value === '72'\n        ? Constants.IN\n        : Constants.MM\n\n    const zeroSuppression = tokens\n      .filter(t => t.type === Lexer.DRILL_ZERO_INCLUSION)\n      .reduce<Types.ZeroSuppression | null>((z, t) => {\n        if (t.value === 'LZ') return Constants.TRAILING\n        if (t.value === 'TZ') return Constants.LEADING\n        return z\n      }, null)\n\n    const format = tokens\n      .filter(t => t.type === Lexer.NUMBER)\n      .reduce<Types.Format | null>((_, t) => {\n        const [integer = '', decimal = ''] = t.value.split('.')\n        return [integer.length, decimal.length]\n      }, null)\n\n    const nodes: Tree.ChildNode[] = [\n      {type: Tree.UNITS, position: tokensToPosition(tokens.slice(0, 2)), units},\n    ]\n\n    if (zeroSuppression || format) {\n      nodes.push({\n        type: Tree.COORDINATE_FORMAT,\n        position: tokensToPosition(tokens.slice(1)),\n        mode: null,\n        format,\n        zeroSuppression,\n      })\n    }\n\n    return nodes\n  },\n}\n\nconst tool: SyntaxRule = {\n  rules: [\n    token(Lexer.T_CODE),\n    minToMax(0, 12, [\n      token(Lexer.COORD_CHAR, 'C'),\n      token(Lexer.COORD_CHAR, 'F'),\n      token(Lexer.COORD_CHAR, 'S'),\n      token(Lexer.COORD_CHAR, 'B'),\n      token(Lexer.COORD_CHAR, 'H'),\n      token(Lexer.COORD_CHAR, 'Z'),\n      token(Lexer.NUMBER),\n    ]),\n    token(Lexer.NEWLINE),\n  ],\n  createNodes: tokens => {\n    const code = tokens[0].value\n    const position = tokensToPosition(tokens)\n    const {c = null} = tokensToCoordinates(tokens.slice(1, -1))\n    const shape: Types.ToolShape | null =\n      c !== null ? {type: Constants.CIRCLE, diameter: Number(c)} : null\n\n    return shape\n      ? [{type: Tree.TOOL_DEFINITION, hole: null, position, shape, code}]\n      : [{type: Tree.TOOL_CHANGE, position, code}]\n  },\n}\n\nconst mode: SyntaxRule = {\n  rules: [\n    one([\n      token(Lexer.G_CODE, '0'),\n      token(Lexer.G_CODE, '1'),\n      token(Lexer.G_CODE, '2'),\n      token(Lexer.G_CODE, '3'),\n      token(Lexer.G_CODE, '5'),\n    ]),\n    token(Lexer.NEWLINE),\n  ],\n  createNodes: tokens => [\n    {\n      type: Tree.INTERPOLATE_MODE,\n      position: tokensToPosition(tokens),\n      mode: tokensToMode(tokens),\n    },\n  ],\n}\n\nconst operation: SyntaxRule = {\n  rules: [\n    minToMax(0, 2, [\n      token(Lexer.T_CODE),\n      token(Lexer.G_CODE, '0'),\n      token(Lexer.G_CODE, '1'),\n      token(Lexer.G_CODE, '2'),\n      token(Lexer.G_CODE, '3'),\n      token(Lexer.G_CODE, '5'),\n    ]),\n    minToMax(2, 8, [token(Lexer.COORD_CHAR), token(Lexer.NUMBER)]),\n    zeroOrOne([token(Lexer.T_CODE)]),\n    token(Lexer.NEWLINE),\n  ],\n  createNodes: tokens => {\n    const graphicTokens = tokens.filter(\n      t => t.type === Lexer.COORD_CHAR || t.type === Lexer.NUMBER\n    )\n    const modeToken = tokens.find(t => t.type === Lexer.G_CODE)\n    const toolToken = tokens.find(t => t.type === Lexer.T_CODE)\n    const coordinates = tokensToCoordinates(graphicTokens)\n    const code = toolToken ? toolToken.value : null\n    const mode = tokensToMode(tokens)\n\n    const graphicPosition = tokensToPosition(tokens, {\n      head: graphicTokens[0],\n      length: graphicTokens.length + 1,\n    })\n    const modePosition = tokensToPosition(tokens, {head: modeToken, length: 2})\n    const toolPosition = tokensToPosition(tokens, {head: toolToken, length: 2})\n\n    const nodes: Tree.ChildNode[] = [\n      {\n        type: Tree.GRAPHIC,\n        position: graphicPosition,\n        graphic: null,\n        coordinates,\n      },\n    ]\n\n    if (mode) {\n      nodes.unshift({type: Tree.INTERPOLATE_MODE, position: modePosition, mode})\n    }\n    if (code) {\n      nodes.unshift({type: Tree.TOOL_CHANGE, position: toolPosition, code})\n    }\n    return nodes\n  },\n}\n\nconst slot: SyntaxRule = {\n  rules: [\n    minToMax(2, 4, [token(Lexer.COORD_CHAR), token(Lexer.NUMBER)]),\n    token(Lexer.G_CODE, '85'),\n    minToMax(2, 4, [token(Lexer.COORD_CHAR), token(Lexer.NUMBER)]),\n    token(Lexer.NEWLINE),\n  ],\n  createNodes: tokens => {\n    const gCode = tokens.find(t => t.type === Lexer.G_CODE)\n    const splitIdx = gCode ? tokens.indexOf(gCode) : -1\n    const start = tokensToCoordinates(tokens.slice(0, splitIdx))\n    const end = tokensToCoordinates(tokens.slice(splitIdx))\n    const coordinates: Types.Coordinates = {}\n\n    Object.keys(start).forEach(k => (coordinates[`${k}1`] = start[k]))\n    Object.keys(end).forEach(k => (coordinates[`${k}2`] = end[k]))\n\n    return [\n      {\n        type: Tree.GRAPHIC,\n        position: tokensToPosition(tokens),\n        graphic: Constants.SLOT,\n        coordinates,\n      },\n    ]\n  },\n}\n\nconst done: SyntaxRule = {\n  rules: [\n    one([token(Lexer.M_CODE, '30'), token(Lexer.M_CODE, '0')]),\n    token(Lexer.NEWLINE),\n  ],\n  createNodes: tokens => [\n    {type: Tree.DONE, position: tokensToPosition(tokens)},\n  ],\n}\n\nconst comment: SyntaxRule = {\n  rules: [\n    token(Lexer.SEMICOLON),\n    zeroOrMore([notToken(Lexer.NEWLINE)]),\n    token(Lexer.NEWLINE),\n  ],\n  createNodes: tokens => [\n    {\n      type: Tree.COMMENT,\n      comment: tokensToString(tokens.slice(1, -1)),\n      position: tokensToPosition(tokens),\n    },\n  ],\n}\n\nexport const drillSyntax: Array<SyntaxRule> = [\n  tool,\n  mode,\n  operation,\n  slot,\n  comment,\n  units,\n  done,\n].map(r => ({...r, filetype: Constants.DRILL}))\n","import {Token} from '../lexer'\nimport {TokenRule, SINGLE_TOKEN, MIN_TO_MAX} from './rules'\nimport {SyntaxRule, MatchState} from './types'\n\nconst FULL_MATCH = 'FULL_MATCH'\nconst PARTIAL_MATCH = 'PARTIAL_MATCH'\nconst NO_MATCH = 'NO_MATCH'\n\ntype ListMatch = typeof FULL_MATCH | typeof PARTIAL_MATCH | typeof NO_MATCH\n\nexport function createMatchSyntax<M>(\n  ...grammar: SyntaxRule<M>[]\n): (state: MatchState<M> | null, token: Token) => MatchState<M> {\n  return (state, token) => matchSyntax(state, token, grammar)\n}\n\nexport function matchSyntax<M>(\n  state: MatchState<M> | null,\n  token: Token,\n  grammar: SyntaxRule<M>[]\n): MatchState<M> {\n  if (state === null) state = {candidates: grammar, tokens: []}\n  const {candidates: prevCandidates} = state\n  const candidates = []\n  const tokens = [...state.tokens, token]\n\n  let i\n  for (i = 0; i < prevCandidates.length; i++) {\n    const rule = prevCandidates[i]\n    const result = tokenListMatches(rule.rules, tokens)\n\n    if (result === FULL_MATCH) {\n      const nodes = rule.createNodes(tokens)\n      return {candidates: [], tokens, nodes, filetype: rule.filetype}\n    }\n\n    if (result === PARTIAL_MATCH) {\n      candidates.push(rule)\n    }\n  }\n\n  return {candidates, tokens}\n}\n\nfunction tokenListMatches(\n  rules: Array<TokenRule>,\n  tokens: Array<Token>\n): ListMatch {\n  let i = 0\n  let j = 0\n  let multiMatchCount = 0\n\n  while (i < rules.length && j < tokens.length) {\n    const rule = rules[i]\n    const token = tokens[j]\n    const match = tokenMatches(rule, token)\n\n    if (match) {\n      if (\n        rule.rule === SINGLE_TOKEN ||\n        (rule.rule === MIN_TO_MAX && multiMatchCount >= rule.max - 1)\n      ) {\n        i++\n        j++\n        multiMatchCount = 0\n      } else if (rule.rule === MIN_TO_MAX) {\n        j++\n        multiMatchCount++\n      }\n    } else if (rule.rule === MIN_TO_MAX && multiMatchCount >= rule.min) {\n      multiMatchCount = 0\n      i++\n    } else {\n      return NO_MATCH\n    }\n  }\n\n  if (i < rules.length) return PARTIAL_MATCH\n  return FULL_MATCH\n}\n\nfunction tokenMatches(rule: TokenRule, token: Token): boolean {\n  if (rule.rule === SINGLE_TOKEN) {\n    const typeResult = rule.type === token.type\n    const valueResult =\n      rule.value == null ||\n      (typeof rule.value === 'string' && rule.value === token.value) ||\n      (rule.value instanceof RegExp && rule.value.test(token.value))\n\n    const result = typeResult && valueResult\n\n    return rule.negate ? !result : result\n  }\n\n  if (Array.isArray(rule.match)) {\n    return rule.match.some(match => tokenMatches(match, token))\n  }\n\n  return false\n}\n","// gerber aperture macro syntax\nimport * as Lexer from '../lexer'\nimport * as Tree from '../tree'\nimport {MacroValue} from '../types'\nimport {SyntaxRule, MatchState} from './types'\nimport {token, notToken, zeroOrMore, oneOrMore} from './rules'\nimport {tokensToPosition} from './map-tokens'\nimport {matchSyntax} from './match-syntax'\n\nconst macroComment: SyntaxRule<Tree.MacroBlock> = {\n  rules: [\n    token(Lexer.NUMBER, '0'),\n    zeroOrMore([notToken(Lexer.ASTERISK)]),\n    token(Lexer.ASTERISK),\n  ],\n  createNodes: createMacroComment,\n}\n\nconst macroVariable: SyntaxRule<Tree.MacroBlock> = {\n  rules: [\n    token(Lexer.GERBER_MACRO_VARIABLE),\n    token(Lexer.EQUALS),\n    oneOrMore([\n      token(Lexer.NUMBER),\n      token(Lexer.OPERATOR),\n      token(Lexer.GERBER_MACRO_VARIABLE),\n      token(Lexer.COORD_CHAR, 'X'),\n    ]),\n    token(Lexer.ASTERISK),\n  ],\n  createNodes: createMacroVariable,\n}\n\nconst macroPrimitive: SyntaxRule<Tree.MacroBlock> = {\n  rules: [\n    token(Lexer.NUMBER),\n    token(Lexer.COMMA),\n    oneOrMore([\n      token(Lexer.COMMA),\n      token(Lexer.NUMBER),\n      token(Lexer.OPERATOR),\n      token(Lexer.GERBER_MACRO_VARIABLE),\n      token(Lexer.COORD_CHAR, 'X'),\n    ]),\n    token(Lexer.ASTERISK),\n  ],\n  createNodes: createMacroPrimitive,\n}\n\nfunction createMacroComment(tokens: Lexer.Token[]): Tree.MacroComment[] {\n  const comment = tokens\n    .slice(1, -1)\n    .map(t => t.text)\n    .join('')\n    .trim()\n\n  return [\n    {type: Tree.MACRO_COMMENT, position: tokensToPosition(tokens), comment},\n  ]\n}\n\nfunction createMacroPrimitive(tokens: Lexer.Token[]): Tree.MacroPrimitive[] {\n  const code = tokens[0].value\n  const modifiers = tokens\n    .slice(2, -1)\n    .reduce<Lexer.Token[][]>(\n      (groups, token) => {\n        const current = groups[groups.length - 1]\n        if (token.type !== Lexer.COMMA) {\n          current.push(token)\n        } else {\n          groups.push([])\n        }\n\n        return groups\n      },\n      [[]]\n    )\n    .map(parseMacroExpression)\n\n  return [\n    {\n      type: Tree.MACRO_PRIMITIVE,\n      position: tokensToPosition(tokens),\n      code,\n      modifiers,\n    },\n  ]\n}\n\nfunction createMacroVariable(tokens: Lexer.Token[]): Tree.MacroVariable[] {\n  const name = tokens[0].value\n  const value = parseMacroExpression(tokens.slice(2, -1))\n\n  return [\n    {\n      type: Tree.MACRO_VARIABLE,\n      position: tokensToPosition(tokens),\n      name,\n      value,\n    },\n  ]\n}\n\nfunction parseMacroExpression(tokens: Lexer.Token[]): MacroValue {\n  const toParse = tokens.map<Lexer.Token>(token => {\n    return token.type === Lexer.COORD_CHAR\n      ? {...token, type: Lexer.OPERATOR, value: 'x'}\n      : token\n  })\n\n  return parseAddition()\n\n  function peekNextToken(): Lexer.Token | null {\n    return toParse[0] ?? null\n  }\n\n  // parse numbers, variables, and parenthesis\n  function parsePrimary(): MacroValue {\n    const token = toParse.shift() as Lexer.Token\n\n    if (token.type === Lexer.NUMBER) return Number(token.value)\n    if (token.type === Lexer.GERBER_MACRO_VARIABLE) return token.value\n\n    // else, we've got a parentheses group, so parse it and consume the \")\"\n    const expression = parseAddition()\n    toParse.shift()\n    return expression\n  }\n\n  // parse multiplication and division operations\n  function parseMultiplication(): MacroValue {\n    let expression = parsePrimary()\n    let nextToken = peekNextToken()\n\n    while (\n      nextToken?.type === Lexer.OPERATOR &&\n      (nextToken.value === 'x' || nextToken.value === '/')\n    ) {\n      toParse.shift()\n      expression = {\n        left: expression,\n        right: parsePrimary(),\n        operator: nextToken.value,\n      }\n      nextToken = peekNextToken()\n    }\n\n    return expression\n  }\n\n  function parseAddition(): MacroValue {\n    let expression = parseMultiplication()\n    let nextToken = peekNextToken()\n\n    while (\n      (nextToken?.type === Lexer.OPERATOR &&\n        (nextToken.value === '+' || nextToken.value === '-')) ||\n      nextToken?.type === Lexer.NUMBER\n    ) {\n      let operator: '+' | '-' = '+'\n      if (nextToken.type === Lexer.OPERATOR) {\n        toParse.shift()\n        operator = nextToken.value as '+' | '-'\n      }\n      const right = parseMultiplication()\n      expression = {left: expression, right, operator}\n      nextToken = peekNextToken()\n    }\n\n    return expression\n  }\n}\n\nconst MACRO_GRAMMAR = [macroPrimitive, macroVariable, macroComment]\n\nexport function parseMacroBlocks(tokens: Lexer.Token[]): Tree.MacroBlock[] {\n  let matchState: MatchState<Tree.MacroBlock> | null = null\n  const blocks: Tree.MacroBlock[] = []\n\n  tokens.forEach(token => {\n    matchState = matchSyntax(matchState, token, MACRO_GRAMMAR)\n    if (matchState.nodes) blocks.push(...matchState.nodes)\n    if (matchState.candidates.length === 0) matchState = null\n  })\n\n  return blocks\n}\n","// gerber file syntax\nimport * as Lexer from '../lexer'\nimport * as Constants from '../constants'\nimport * as Types from '../types'\nimport * as Tree from '../tree'\nimport {token, notToken, one, zeroOrMore, zeroOrOne, minToMax} from './rules'\nimport {parseMacroBlocks} from './macro'\nimport {SyntaxRule} from './types'\n\nimport {\n  tokensToCoordinates,\n  tokensToMode,\n  tokensToGraphic,\n  tokensToString,\n  tokensToPosition,\n} from './map-tokens'\n\nconst holeParamsToShape = (params: number[]): Types.HoleShape | null => {\n  if (params.length === 1) {\n    const [diameter] = params\n    return {type: Constants.CIRCLE, diameter}\n  }\n\n  if (params.length === 2) {\n    const [xSize, ySize] = params\n    return {type: Constants.RECTANGLE, xSize, ySize}\n  }\n\n  return null\n}\n\nconst done: SyntaxRule = {\n  rules: [\n    one([token(Lexer.M_CODE, '0'), token(Lexer.M_CODE, '2')]),\n    token(Lexer.ASTERISK),\n  ],\n  createNodes: tokens => [\n    {type: Tree.DONE, position: tokensToPosition(tokens)},\n  ],\n}\n\nconst comment: SyntaxRule = {\n  rules: [\n    token(Lexer.G_CODE, '4'),\n    zeroOrMore([notToken(Lexer.ASTERISK)]),\n    token(Lexer.ASTERISK),\n  ],\n  createNodes: tokens => [\n    {\n      type: Tree.COMMENT,\n      position: tokensToPosition(tokens),\n      comment: tokensToString(tokens.slice(1, -1)),\n    },\n  ],\n}\n\nconst format: SyntaxRule = {\n  rules: [\n    token(Lexer.PERCENT),\n    token(Lexer.GERBER_FORMAT),\n    zeroOrMore([notToken(Lexer.COORD_CHAR, 'X')]),\n    token(Lexer.COORD_CHAR, 'X'),\n    token(Lexer.NUMBER),\n    token(Lexer.COORD_CHAR, 'Y'),\n    token(Lexer.NUMBER),\n    zeroOrMore([notToken(Lexer.ASTERISK)]),\n    token(Lexer.ASTERISK),\n    // including units here is invalid syntax, but Cadence Allegro does it\n    // https://github.com/tracespace/tracespace/issues/234\n    minToMax(0, 2, [token(Lexer.GERBER_UNITS), token(Lexer.ASTERISK)]),\n    token(Lexer.PERCENT),\n  ],\n  createNodes: tokens => {\n    let format: Types.Format | null = null\n    let zeroSuppression = null\n    let mode = null\n    const coords = tokensToCoordinates(tokens)\n    const formatEndIdx = tokens.findIndex(t => t.type === Lexer.ASTERISK)\n    const unitsToken = tokens.find(t => t.type === Lexer.GERBER_UNITS)\n\n    tokens\n      .filter(t => t.type === Lexer.GERBER_FORMAT)\n      .forEach(t => {\n        if (t.value.indexOf('T') >= 0) zeroSuppression = Constants.TRAILING\n        if (t.value.indexOf('L') >= 0) zeroSuppression = Constants.LEADING\n        if (t.value.indexOf('I') >= 0) mode = Constants.INCREMENTAL\n        if (t.value.indexOf('A') >= 0) mode = Constants.ABSOLUTE\n      })\n\n    if (coords.x === coords.y && coords.x?.length === 2) {\n      const integers = Number(coords.x[0])\n      const decimals = Number(coords.x[1])\n      if (integers && decimals) format = [integers, decimals]\n    }\n\n    const nodes: Array<Tree.ChildNode> = [\n      {\n        type: Tree.COORDINATE_FORMAT,\n        position: tokensToPosition(tokens.slice(1, formatEndIdx + 1)),\n        zeroSuppression,\n        format,\n        mode,\n      },\n    ]\n\n    if (unitsToken) {\n      nodes.push({\n        type: Tree.UNITS,\n        position: tokensToPosition(tokens.slice(1, -1), {head: unitsToken}),\n        units: unitsToken.value === 'MM' ? Constants.MM : Constants.IN,\n      })\n    }\n\n    return nodes\n  },\n}\n\nconst units: SyntaxRule = {\n  rules: [\n    token(Lexer.PERCENT),\n    token(Lexer.GERBER_UNITS),\n    token(Lexer.ASTERISK),\n    token(Lexer.PERCENT),\n  ],\n  createNodes: tokens => [\n    {\n      type: Tree.UNITS,\n      position: tokensToPosition(tokens.slice(1, -1)),\n      units: tokens[1].value === 'MM' ? Constants.MM : Constants.IN,\n    },\n  ],\n}\n\nconst toolMacro: SyntaxRule = {\n  rules: [\n    token(Lexer.PERCENT),\n    token(Lexer.GERBER_TOOL_MACRO),\n    token(Lexer.ASTERISK),\n    zeroOrMore([notToken(Lexer.PERCENT)]),\n    token(Lexer.PERCENT),\n  ],\n  createNodes: tokens => {\n    const name = tokens[1].value\n    const position = tokensToPosition(tokens.slice(1, -1))\n    const blockTokens = tokens.slice(3, -1)\n\n    return [\n      {\n        type: Tree.TOOL_MACRO,\n        position,\n        children: parseMacroBlocks(blockTokens),\n        name,\n      },\n    ]\n  },\n}\n\nconst toolDefinition: SyntaxRule = {\n  rules: [\n    token(Lexer.PERCENT),\n    token(Lexer.GERBER_TOOL_DEF),\n    zeroOrMore([\n      token(Lexer.COMMA),\n      token(Lexer.NUMBER),\n      token(Lexer.COORD_CHAR, 'X'),\n    ]),\n    token(Lexer.ASTERISK),\n    token(Lexer.PERCENT),\n  ],\n  createNodes: tokens => {\n    let shape: Types.ToolShape\n    let hole: Types.HoleShape | null = null\n\n    const toolProps = tokens[1].value.match(/(\\d+)(.+)/)\n    const [, code = '', name = ''] = toolProps ?? []\n    const params: Array<number> = tokens\n      .slice(3, -2)\n      .filter(t => t.type === Lexer.NUMBER)\n      .map(t => Number(t.value))\n\n    if (name === 'C') {\n      const [diameter, ...holeParams] = params\n      shape = {type: Constants.CIRCLE, diameter}\n      hole = holeParamsToShape(holeParams)\n    } else if (name === 'R' || name === 'O') {\n      const [xSize, ySize, ...holeParams] = params\n      const type = name === 'R' ? Constants.RECTANGLE : Constants.OBROUND\n      shape = {type, xSize, ySize}\n      hole = holeParamsToShape(holeParams)\n    } else if (name === 'P') {\n      const [diameter, vertices, rotation = null, ...holeParams] = params\n      shape = {type: Constants.POLYGON, diameter, vertices, rotation}\n      hole = holeParamsToShape(holeParams)\n    } else {\n      shape = {type: Constants.MACRO_SHAPE, name, params}\n    }\n\n    return [\n      {\n        type: Tree.TOOL_DEFINITION,\n        position: tokensToPosition(tokens.slice(1, -1)),\n        code,\n        shape,\n        hole,\n      },\n    ]\n  },\n}\n\nconst toolChange: SyntaxRule = {\n  rules: [\n    zeroOrOne([token(Lexer.G_CODE, '54')]),\n    token(Lexer.D_CODE),\n    token(Lexer.ASTERISK),\n  ],\n  createNodes: tokens => [\n    {\n      type: Tree.TOOL_CHANGE,\n      position: tokensToPosition(tokens),\n      code: tokens.find(t => t.type === Lexer.D_CODE)?.value as string,\n    },\n  ],\n}\n\nconst createOperationNodes = (tokens: Lexer.Token[]): Tree.ChildNode[] => {\n  const graphic = tokensToGraphic(tokens)\n  const coordinates = tokensToCoordinates(tokens)\n  const mode = tokensToMode(tokens)\n  const position = tokensToPosition(tokens, {\n    head: mode ? tokens[1] : tokens[0],\n  })\n  const nodes: Tree.ChildNode[] = [\n    {type: Tree.GRAPHIC, position, graphic, coordinates},\n  ]\n  if (mode) {\n    const modePosition = tokensToPosition(tokens, {head: tokens[0], length: 2})\n    nodes.unshift({type: Tree.INTERPOLATE_MODE, position: modePosition, mode})\n  }\n  return nodes\n}\n\nconst operation: SyntaxRule = {\n  rules: [\n    zeroOrOne([\n      token(Lexer.G_CODE, '1'),\n      token(Lexer.G_CODE, '2'),\n      token(Lexer.G_CODE, '3'),\n    ]),\n    minToMax(2, 8, [token(Lexer.COORD_CHAR), token(Lexer.NUMBER)]),\n    zeroOrOne([\n      token(Lexer.D_CODE, '1'),\n      token(Lexer.D_CODE, '2'),\n      token(Lexer.D_CODE, '3'),\n    ]),\n    token(Lexer.ASTERISK),\n  ],\n  createNodes: createOperationNodes,\n}\n\nconst operationWithoutCoords: SyntaxRule = {\n  rules: [\n    zeroOrOne([\n      token(Lexer.G_CODE, '1'),\n      token(Lexer.G_CODE, '2'),\n      token(Lexer.G_CODE, '3'),\n    ]),\n    one([\n      token(Lexer.D_CODE, '1'),\n      token(Lexer.D_CODE, '2'),\n      token(Lexer.D_CODE, '3'),\n    ]),\n    token(Lexer.ASTERISK),\n  ],\n  createNodes: createOperationNodes,\n}\n\nconst interpolationMode: SyntaxRule = {\n  rules: [\n    one([\n      token(Lexer.G_CODE, '1'),\n      token(Lexer.G_CODE, '2'),\n      token(Lexer.G_CODE, '3'),\n    ]),\n    token(Lexer.ASTERISK),\n  ],\n  createNodes: tokens => [\n    {\n      type: Tree.INTERPOLATE_MODE,\n      position: tokensToPosition(tokens),\n      mode: tokensToMode(tokens),\n    },\n  ],\n}\n\nconst regionMode: SyntaxRule = {\n  rules: [\n    one([token(Lexer.G_CODE, '36'), token(Lexer.G_CODE, '37')]),\n    token(Lexer.ASTERISK),\n  ],\n  createNodes: tokens => [\n    {\n      type: Tree.REGION_MODE,\n      position: tokensToPosition(tokens),\n      region: tokens[0].value === '36',\n    },\n  ],\n}\n\nconst quadrantMode: SyntaxRule = {\n  rules: [\n    one([token(Lexer.G_CODE, '74'), token(Lexer.G_CODE, '75')]),\n    token(Lexer.ASTERISK),\n  ],\n  createNodes: tokens => [\n    {\n      type: Tree.QUADRANT_MODE,\n      position: tokensToPosition(tokens),\n      quadrant: tokens[0].value === '74' ? Constants.SINGLE : Constants.MULTI,\n    },\n  ],\n}\n\nconst loadPolarity: SyntaxRule = {\n  rules: [\n    token(Lexer.PERCENT),\n    token(Lexer.GERBER_LOAD_POLARITY),\n    token(Lexer.ASTERISK),\n    token(Lexer.PERCENT),\n  ],\n  createNodes: tokens => [\n    {\n      type: Tree.LOAD_POLARITY,\n      position: tokensToPosition(tokens.slice(1, -1)),\n      polarity: tokens[1].value === 'D' ? Constants.DARK : Constants.CLEAR,\n    },\n  ],\n}\n\nconst stepRepeat: SyntaxRule = {\n  rules: [\n    token(Lexer.PERCENT),\n    token(Lexer.GERBER_STEP_REPEAT),\n    zeroOrMore([token(Lexer.COORD_CHAR), token(Lexer.NUMBER)]),\n    token(Lexer.ASTERISK),\n    token(Lexer.PERCENT),\n  ],\n  createNodes: tokens => {\n    const coordinates = tokensToCoordinates(tokens)\n    const params = Object.keys(coordinates).reduce((res, axis) => {\n      res[axis] = Number(coordinates[axis])\n      return res\n    }, {} as Types.StepRepeatParameters)\n\n    return [\n      {\n        type: Tree.STEP_REPEAT,\n        position: tokensToPosition(tokens.slice(1, -1)),\n        stepRepeat: params,\n      },\n    ]\n  },\n}\n\nconst unimplementedExtendedCommand: SyntaxRule = {\n  rules: [\n    token(Lexer.PERCENT),\n    zeroOrMore([notToken(Lexer.ASTERISK)]),\n    token(Lexer.ASTERISK),\n    token(Lexer.PERCENT),\n  ],\n  createNodes: tokens => [\n    {\n      type: Tree.UNIMPLEMENTED,\n      position: tokensToPosition(tokens.slice(1, -1)),\n      value: tokensToString(tokens),\n    },\n  ],\n}\n\nexport const gerberSyntax: Array<SyntaxRule> = [\n  operation,\n  operationWithoutCoords,\n  interpolationMode,\n  toolChange,\n  toolDefinition,\n  toolMacro,\n  comment,\n  regionMode,\n  quadrantMode,\n  loadPolarity,\n  stepRepeat,\n  format,\n  units,\n  done,\n  unimplementedExtendedCommand,\n].map(r => ({...r, filetype: Constants.GERBER}))\n","import {drillSyntax} from './drill'\nimport {gerberSyntax} from './gerber'\nimport {createMatchSyntax} from './match-syntax'\n\nexport * from './types'\n\nexport const matchSyntax = createMatchSyntax(...gerberSyntax, ...drillSyntax)\n","import {createLexer, Lexer, Token} from './lexer'\nimport {matchSyntax, MatchState} from './syntax'\nimport {Root, ROOT, DONE} from './tree'\n\n/**\n * Gerber and NC drill file parser.\n *\n * @category Parser\n */\nexport interface Parser {\n  /** Parser's {@linkcode Lexer} instance */\n  lexer: Lexer\n  /** Feed the parser with all or part of the source file */\n  feed(chunk: string): void\n  /** Get the resulting AST when you are done feeding the parser */\n  results(): Root\n}\n\n/**\n * {@linkcode Parser} factory and the primary export of the library.\n *\n * @example\n * ```ts\n * import {createParser} from '@tracespace/parser'\n *\n * // create a parser to parse a single file\n * const parser = createParser()\n *\n * // feed the parser the source file contents\n * parser.feed('G04 gerber file contents*\\nM02*\\n')\n *\n * // get the resulting AST\n * const tree = parser.results()\n * ```\n *\n * @category Parser\n */\nexport function createParser(): Parser {\n  const lexer = createLexer()\n  const root: Root = {type: ROOT, filetype: null, done: false, children: []}\n\n  let stash = ''\n  let lexerOffset = 0\n  let lexerState = lexer.save()\n\n  return {lexer, feed, results}\n\n  function feed(chunk: string): void {\n    const currentStash = stash\n    const currentOffset = lexerOffset\n    let matchState: MatchState | null = null\n    let nextToken: Token | undefined\n\n    stash = ''\n    lexer.reset(`${currentStash}${chunk}`, lexerState)\n\n    while ((nextToken = lexer.next())) {\n      const token = {...nextToken, offset: nextToken.offset + currentOffset}\n      stash += nextToken.text\n      matchState = matchSyntax(matchState, token)\n\n      if (matchState.nodes) {\n        const {nodes, filetype = null} = matchState\n        stash = ''\n        lexerOffset += lexer.index ?? 0\n        lexerState = lexer.save()\n        root.children.push(...nodes)\n        root.filetype = root.filetype ?? filetype\n        root.done = root.done || nodes.some(n => n.type === DONE)\n      }\n\n      if (matchState.candidates.length === 0) {\n        matchState = null\n      }\n    }\n  }\n\n  function results(): Root {\n    return root\n  }\n}\n"],"names":["GERBER","DRILL","MM","IN","LEADING","TRAILING","ABSOLUTE","INCREMENTAL","CIRCLE","RECTANGLE","OBROUND","POLYGON","MACRO_SHAPE","MACRO_CIRCLE","MACRO_VECTOR_LINE","MACRO_CENTER_LINE","MACRO_OUTLINE","MACRO_POLYGON","MACRO_MOIRE","MACRO_THERMAL","SHAPE","MOVE","SEGMENT","SLOT","LINE","CW_ARC","CCW_ARC","SINGLE","MULTI","DARK","CLEAR","T_CODE","G_CODE","M_CODE","D_CODE","ASTERISK","PERCENT","EQUALS","COMMA","OPERATOR","GERBER_FORMAT","GERBER_UNITS","GERBER_TOOL_MACRO","GERBER_TOOL_DEF","GERBER_LOAD_POLARITY","GERBER_STEP_REPEAT","GERBER_MACRO_VARIABLE","SEMICOLON","DRILL_UNITS","DRILL_ZERO_INCLUSION","COORD_CHAR","NUMBER","WORD","WHITESPACE","NEWLINE","CATCHALL","ERROR","RE_STRIP_LEADING_ZEROS","stripLeadingZeros","text","replace","getCodeValue","slice","rules","Tokens","match","value","lineBreaks","Moo","error","createLexer","compile","ROOT","COMMENT","DONE","UNITS","COORDINATE_FORMAT","TOOL_DEFINITION","TOOL_MACRO","TOOL_CHANGE","LOAD_POLARITY","STEP_REPEAT","GRAPHIC","INTERPOLATE_MODE","REGION_MODE","QUADRANT_MODE","UNIMPLEMENTED","MACRO_COMMENT","MACRO_VARIABLE","MACRO_PRIMITIVE","SINGLE_TOKEN","MIN_TO_MAX","token","type","rule","notToken","negate","one","min","max","zeroOrOne","zeroOrMore","Infinity","oneOrMore","minToMax","tokensToCoordinates","tokens","reduce","coords","i","prev","toLowerCase","tokensToMode","filter","t","m","tokensToGraphic","g","tokensToString","map","join","trim","tokensToPosition","options","head","tail","length","indexOf","start","line","column","col","offset","end","units","Lexer","createNodes","Constants","zeroSuppression","z","format","_","split","integer","decimal","nodes","Tree","position","push","mode","tool","code","c","shape","diameter","Number","hole","operation","graphicTokens","modeToken","find","toolToken","coordinates","graphicPosition","modePosition","toolPosition","graphic","unshift","slot","gCode","splitIdx","Object","keys","forEach","k","done","comment","drillSyntax","r","filetype","FULL_MATCH","PARTIAL_MATCH","NO_MATCH","createMatchSyntax","grammar","state","matchSyntax","candidates","prevCandidates","result","tokenListMatches","j","multiMatchCount","tokenMatches","typeResult","valueResult","RegExp","test","Array","isArray","some","macroComment","createMacroComment","macroVariable","createMacroVariable","macroPrimitive","createMacroPrimitive","modifiers","groups","current","parseMacroExpression","name","toParse","parseAddition","peekNextToken","parsePrimary","shift","expression","parseMultiplication","nextToken","left","right","operator","MACRO_GRAMMAR","parseMacroBlocks","matchState","blocks","holeParamsToShape","params","xSize","ySize","formatEndIdx","findIndex","unitsToken","x","y","integers","decimals","toolMacro","blockTokens","children","toolDefinition","toolProps","holeParams","vertices","rotation","toolChange","createOperationNodes","operationWithoutCoords","interpolationMode","regionMode","region","quadrantMode","quadrant","loadPolarity","polarity","stepRepeat","res","axis","unimplementedExtendedCommand","gerberSyntax","createParser","lexer","root","stash","lexerOffset","lexerState","save","feed","results","chunk","currentStash","currentOffset","reset","next","index","n"],"mappings":"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"}