{"version":3,"sources":["webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/errors-browser.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/_stream_duplex.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/errors-browser.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/_stream_duplex.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/errors-browser.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/_stream_duplex.js","webpack:////home/user/tracespace/node_modules/lodash.isfinite/index.js","webpack:////home/user/tracespace/packages/gerber-to-svg/lib/_util.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/normalize-coord.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack:////home/user/tracespace/packages/gerber-plotter/lib/_box.js","webpack:////home/user/tracespace/node_modules/xml-element-string/index.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/_stream_readable.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/internal/streams/state.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/_stream_writable.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/_stream_transform.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/_commands.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/parse-coord.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/_drill-mode.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/_stream_readable.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/internal/streams/state.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/_stream_writable.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/_stream_transform.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/_stream_readable.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/internal/streams/state.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/_stream_writable.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/_stream_transform.js","webpack:////home/user/tracespace/packages/gerber-to-svg/render.js","webpack:////home/user/tracespace/packages/pcb-stackup-core/lib/board-color.js","webpack:////home/user/tracespace/node_modules/run-parallel/index.js","webpack:////home/user/tracespace/node_modules/run-waterfall/index.js","webpack:////home/user/tracespace/packages/gerber-to-svg/index.js","webpack:////home/user/tracespace/packages/gerber-parser/index.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/parser.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/readable-browser.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/experimentalWarning.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/internal/streams/async_iterator.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/_stream_passthrough.js","webpack:////home/user/tracespace/packages/gerber-parser/node_modules/readable-stream/lib/internal/streams/pipeline.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/_determine-filetype.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/get-next-block.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/_parse-gerber.js","webpack:////home/user/tracespace/node_modules/lodash.padstart/index.js","webpack:////home/user/tracespace/node_modules/lodash.padend/index.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/_parse-macro-block.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/_parse-macro-expression.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/_parse-drill.js","webpack:////home/user/tracespace/packages/gerber-parser/lib/_warning.js","webpack:////home/user/tracespace/packages/gerber-plotter/index.js","webpack:////home/user/tracespace/packages/gerber-plotter/lib/plotter.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/readable-browser.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/experimentalWarning.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/internal/streams/async_iterator.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/_stream_passthrough.js","webpack:////home/user/tracespace/packages/gerber-plotter/node_modules/readable-stream/lib/internal/streams/pipeline.js","webpack:////home/user/tracespace/packages/gerber-plotter/lib/path-graph.js","webpack:////home/user/tracespace/node_modules/lodash.fill/index.js","webpack:////home/user/tracespace/packages/gerber-plotter/lib/_warning.js","webpack:////home/user/tracespace/packages/gerber-plotter/lib/_pad-shape.js","webpack:////home/user/tracespace/node_modules/lodash.isfunction/index.js","webpack:////home/user/tracespace/packages/gerber-plotter/lib/_operate.js","webpack:////home/user/tracespace/node_modules/escape-html/index.js","webpack:////home/user/tracespace/packages/gerber-to-svg/lib/plotter-to-svg.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/readable-browser.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/experimentalWarning.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/internal/streams/async_iterator.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/_stream_passthrough.js","webpack:////home/user/tracespace/packages/gerber-to-svg/node_modules/readable-stream/lib/internal/streams/pipeline.js","webpack:////home/user/tracespace/packages/gerber-to-svg/lib/_reduce-shape.js","webpack:////home/user/tracespace/packages/gerber-to-svg/lib/_flash-pad.js","webpack:////home/user/tracespace/packages/gerber-to-svg/lib/_create-path.js","webpack:////home/user/tracespace/packages/pcb-stackup-core/index.js","webpack:////home/user/tracespace/node_modules/color-string/index.js","webpack:////home/user/tracespace/node_modules/color-name/index.js","webpack:////home/user/tracespace/node_modules/simple-swizzle/index.js","webpack:////home/user/tracespace/node_modules/simple-swizzle/node_modules/is-arrayish/index.js","webpack:////home/user/tracespace/packages/pcb-stackup-core/lib/parse-options.js","webpack:////home/user/tracespace/packages/pcb-stackup-core/lib/sort-layers.js","webpack:////home/user/tracespace/packages/pcb-stackup-core/lib/stack-layers.js","webpack:////home/user/tracespace/packages/pcb-stackup-core/lib/_gather-layers.js","webpack:////home/user/tracespace/packages/pcb-stackup-core/lib/wrap-layer.js","webpack:////home/user/tracespace/packages/pcb-stackup-core/lib/instruction_svg_template_b64.js","webpack:////home/user/tracespace/packages/pcb-stackup/index.js"],"names":["codes","createErrorType","code","message","Base","Error","NodeError","_Base","subClass","superClass","arg1","arg2","arg3","call","this","getMessage","prototype","Object","create","constructor","__proto__","name","oneOf","expected","thing","Array","isArray","len","length","map","i","String","concat","slice","join","value","TypeError","actual","determiner","search","pos","msg","substr","replace","str","this_len","undefined","substring","endsWith","type","start","indexOf","includes","arg","module","exports","objectKeys","keys","obj","key","push","Duplex","Readable","Writable","v","method","options","allowHalfOpen","readable","writable","once","onend","_writableState","ended","process","nextTick","onEndNT","self","end","defineProperty","enumerable","get","highWaterMark","getBuffer","_readableState","destroyed","set","freeGlobal","global","freeSelf","nativeIsFinite","Function","isFinite","shift","number","Math","round","boundingRect","box","fill","element","x","y","width","height","maskLayer","maskId","layer","mask","createMask","children","id","stroke","ERR_STREAM_PREMATURE_CLOSE","noop","eos","stream","opts","callback","called","_len","arguments","args","_key","apply","onlegacyfinish","onfinish","writableEnded","finished","readableEnded","endEmitted","onerror","err","onclose","onrequest","req","on","setHeader","abort","isRequest","error","removeListener","numIsFinite","padLeft","padRight","format","NaN","numberString","sign","zero","Number","places","leading","trailing","before","after","add","target","min","max","translate","delta","dx","dy","new","Infinity","addPoint","point","addCircle","r","cx","cy","repeat","escapeHtml","tag","attributes","reduce","result","ReadableState","EventEmitter","EElistenerCount","emitter","listeners","Stream","Buffer","OurUint8Array","Uint8Array","debug","debugUtil","debuglog","StringDecoder","createReadableStreamAsyncIterator","BufferList","destroyImpl","getHighWaterMark","_require$codes","ERR_INVALID_ARG_TYPE","ERR_STREAM_PUSH_AFTER_EOF","ERR_METHOD_NOT_IMPLEMENTED","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","emitExperimentalWarning","kProxyEvents","isDuplex","objectMode","readableObjectMode","buffer","pipes","pipesCount","flowing","reading","sync","needReadable","emittedReadable","readableListening","resumeScheduled","paused","emitClose","defaultEncoding","awaitDrain","readingMore","decoder","encoding","read","_read","destroy","_destroy","readableAddChunk","chunk","addToFront","skipChunkCheck","er","state","emitReadable","emitReadable_","onEofChunk","isBuffer","chunkInvalid","emit","getPrototypeOf","from","_uint8ArrayToBuffer","addChunk","write","maybeReadMore","unshift","_undestroy","undestroy","cb","isPaused","setEncoding","enc","MAX_HWM","howMuchToRead","n","head","data","computeNewHighWaterMark","flow","maybeReadMore_","updateReadableListening","listenerCount","resume","nReadingNextTick","resume_","fromList","ret","first","clear","consume","endReadable","endReadableNT","xs","l","parseInt","nOrig","doRead","pipe","dest","pipeOpts","src","endFn","stdout","stderr","unpipe","onunpipe","unpipeInfo","hasUnpiped","ondrain","ondata","cleanedUp","needDrain","pipeOnDrain","pause","event","fn","prependListener","_events","dests","index","splice","ev","res","addListener","removeAllListeners","wrap","_this","bind","Symbol","asyncIterator","_fromList","emitErrorAndCloseNT","emitErrorNT","emitCloseNT","readableDestroyed","writableDestroyed","errorEmitted","ending","finalCalled","prefinished","ERR_INVALID_OPT_VALUE","duplexKey","hwm","highWaterMarkFrom","floor","CorkedRequest","next","entry","finish","corkReq","pendingcb","corkedRequestsFree","onCorkedFinish","WritableState","internalUtil","deprecate","realHasInstance","ERR_MULTIPLE_CALLBACK","ERR_STREAM_CANNOT_PIPE","ERR_STREAM_DESTROYED","ERR_STREAM_NULL_VALUES","ERR_STREAM_WRITE_AFTER_END","ERR_UNKNOWN_ENCODING","nop","writableObjectMode","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writecb","writelen","onwriteStateUpdate","finishMaybe","onwriteError","needFinish","bufferedRequest","clearBuffer","afterWrite","lastBufferedRequest","bufferedRequestCount","_write","writev","_writev","final","_final","doWrite","onwriteDrain","holder","count","allBuffers","isBuf","callFinal","need","prefinish","current","out","_","hasInstance","object","writeAfterEnd","validChunk","newChunk","decodeChunk","last","writeOrBuffer","cork","uncork","setDefaultEncoding","toLowerCase","endWritable","Transform","ERR_TRANSFORM_ALREADY_TRANSFORMING","ERR_TRANSFORM_WITH_LENGTH_0","afterTransform","ts","_transformState","transforming","writechunk","rs","needTransform","writeencoding","transform","_transform","flush","_flush","done","err2","commandMap","property","line","prop","level","tool","op","operation","location","coord","macro","blocks","normalize","RE_TRAILING","RE_LEADING","MATCH","test","parse","matcher","coordMatch","match","detectZero","DRILL","MOVE","LINEAR","CW_ARC","CCW_ARC","xmlElementString","converter","attr","createElement","version","xmlns","units","viewBox","forEach","defs","colorString","LAYER_IDS","DEFAULTS","fr4","cu","cf","sm","ss","sp","getColor","overrides","color","getStyleElement","prefix","side","parsedColor","css","components","alpha","model","to","hex","colorToCssString","tasks","results","pending","isSync","each","task","xid","gerberParser","gerberPlotter","PlotterToSvg","render","clone","gerber","inputOpts","ensure","parser","filetype","plotter","backupUnits","nota","backupNota","optimizePaths","plotAsOutline","callbackMode","w","e","finishConversion","Parser","p","verifyPlaces","z","verifyZero","f","verifyFiletype","inherits","determineFiletype","getNext","parseGerber","parseDrill","warning","drillMode","_decoder","_stash","_index","_drillMode","_drillStash","_syncResult","_process","lines","rem","block","_push","_warn","parseSync","file","PassThrough","pipeline","_defineProperty","configurable","inspect","custom","tail","_proto","s","alloc","offset","allocUnsafe","copy","hasStrings","_getString","_getBuffer","c","nb","buf","source","ownKeys","getOwnPropertySymbols","filter","sym","getOwnPropertyDescriptor","_objectSpread","depth","customInspect","experimentalWarnings","Set","emitWarning","feature","has","_Object$setPrototypeO","kLastResolve","kLastReject","kError","kEnded","kLastPromise","kHandlePromise","kStream","createIterResult","readAndResolve","iter","resolve","AsyncIteratorPrototype","ReadableStreamAsyncIteratorPrototype","setPrototypeOf","Promise","reject","promise","lastPromise","then","wrapForNext","_this2","_Object$create","iterator","ERR_MISSING_ARGS","streams","pop","popCallback","destroys","closed","destroyer","LIMIT","limit","split","param","splitFound","paramStarted","paramFound","blockFound","found","trim","commands","parseCoord","parseMacroBlock","RE_MODE","RE_REGION","RE_ARC","RE_BKP_UNITS","RE_BKP_NOTA","RE_COMMENT","RE_TOOL","RE_OP","RE_COORD","RE_UNITS","RE_FORMAT","RE_POLARITY","RE_STEP_REP","RE_TOOL_DEF","RE_MACRO","region","arc","formatMatch","unknown","epsilon","pow","polarity","stepRepeatMatch","j","sr","shape","maxArgs","val","toolMatch","shapeMatch","toolArgs","hole","toolDef","params","parseToolDef","macroMatch","Boolean","parseMacroDef","mode","opMatch","modeMatch","opCode","coordString","INFINITY","MAX_SAFE_INTEGER","MAX_INTEGER","NAN","symbolTag","reTrim","reIsBadHex","reIsBinary","reIsOctal","rsAstral","rsCombo","rsFitz","rsNonAstral","rsRegional","rsSurrPair","reOptMod","rsSeq","rsSymbol","reUnicode","RegExp","reHasUnicode","freeParseInt","root","asciiSize","hasUnicode","string","stringSize","lastIndex","unicodeSize","stringToArray","unicodeToArray","asciiToArray","objectToString","toString","nativeCeil","ceil","nativeFloor","symbolProto","symbolToString","baseRepeat","baseToString","isSymbol","castSlice","array","baseSlice","isObject","isObjectLike","toFinite","other","valueOf","isBinary","toNumber","chars","strLength","remainder","toInteger","charsLength","createPadding","parseMacroExpr","RE_NUM","RE_VAR_DEF","varDefMatch","varName","varExpr","evaluate","mods","m","exp","dia","rot","x1","y1","x2","y2","points","vertices","ringThx","ringGap","maxRings","crossThx","crossLen","outerDia","innerDia","gap","RE_NUMBER","RE_TOKEN","expr","parseExpression","tokens","parsePrimary","t","parseMultiplication","left","right","tree","RE_ALTIUM_HINT","RE_ALTIUM_PLATING_HINT","RE_KI_HINT","RE_ZERO","RE_TOOL_SET","RE_ROUTE","parseBlock","toolCode","toolSet","coordToCommand","unitsMatch","zeroMatch","keep","parseUnits","formatHints","kicadMatch","absolute","unitSet","suppressionSet","altiumMatch","holePlating","parseCommentForFormatHints","Plotter","verifyNota","verifyUnits","PathGraph","padShape","operate","boundingBox","_formatLock","_plotAsOutline","_optimizePaths","_line","_done","_tool","_outTool","_tools","_macros","_pos","_box","_mode","_arc","_region","_path","_epsilon","_lastOp","_stepRep","_finishPath","doNotOptimize","path","traverse","trace","_checkFormat","_updateBox","stepRepLen","repeatBox","a","shapeAndBox","pad","flashed","levelValue","offsets","find","collection","condition","findClosest","position","fillGaps","prev","d","distance","sqrt","pointsEqual","optimize","_edges","_optimize","_fillGaps","newSeg","edge","segment","_fillGapsAndOptimize","newSegs","seg","edges","startIndex","endIndex","otherPoints","newEdgeIndex","currentEdge","currentEnd","currentSegment","reversed","walked","discovered","lastEnd","center","radius","sweep","dir","reverse","MAX_ARRAY_LENGTH","funcTag","genTag","reIsUint","baseFill","lower","upper","toLength","isIterateeCall","isLength","isFunction","isArrayLike","isIndex","eq","roundToPrecision","rounded","rotatePointAboutOrigin","PI","sin","cos","circle","rotatedCenter","vect","hWidth","rect","hHeight","regularPolygon","nPoints","theta","step","ring","runMacro","emptyMacro","exposure","flatPoints","outlinePolygon","halfThx","gapAndHalfThx","horCross","verCross","moire","clip","thermal","macros","holeShape","toolShape","asyncTag","nullTag","proxyTag","undefinedTag","objectProto","hasOwnProperty","nativeObjectToString","symToStringTag","toStringTag","baseGetTag","isOwn","unmasked","getRawTag","HALF_PI","TWO_PI","THREE_HALF_PI","roundToZero","drawArc","pathGraph","validCenters","candidates","xCandidates","yCandidates","xAve","yAve","deltaX","deltaY","halfDistance","squareDifference","yOffset","arcCenterFromRadius","startDist","endDist","abs","cenAndAngles","centers","thetaStart","thetaEnd","candidate","atan2","findCenterAndAngles","startPoint","endPoint","mBox","arcBox","interpolate","startBox","endBox","drawLine","sXMin","sXMax","sYMin","sYMax","eXMin","eXMax","eYMin","eYMax","interpolateRect","flash","matchHtmlRegExp","escape","exec","html","charCodeAt","reduceShapeArray","flashPad","createPath","util","_maskId","_maskBox","_mask","_blockMode","_blockBox","_block","_blockCount","_blockLayerCount","_offsets","_clearCount","_lastLayer","_element","_draw","_handleNewPolarity","_handleNewRepeat","_handleSize","_finishBlockLayer","blockLayerId","_finishClearLayer","endOfBlock","wasClear","blockMode","blockLayers","blockIdStart","isDark","every","rx","ry","poly","pointsAttr","shapeArray","maskIdPrefix","image","svg","clipNodes","shapes","maskUrl","circleNode","groupChildren","node","masks","nextMaskId","maskBox","maskChildren","layers","svgElement","lastCmd","half","reduceSegments","move","segments","extend","wtg","vb","boardColor","parseOptions","sortLayers","stackLayers","SIDES","SIDE_TOP","SIDE_BOTTOM","BASE_ATTRIBUTES","INSNS_B64","getGroupAttributes","mechMaskId","outClipId","xTranslation","getLayerAttributes","sorted","useOutline","stacks","drills","outline","stack","style","layerPads","copies","layerOutline","defsNode","layerNode","padsNode","outlineNode","sideAttributes","asString","insnsNode","backgroundRect","inkscapeLayerBackground","inkscapeLayerInsns","inkscapeLayerRender","inkscapeLayerPads","inkscapeLayerOutline","inkscapeLayerTPs","inkscapeLayerMount","inkscapeLayerGrip","colorNames","swizzle","reverseNames","cs","clamp","num","hexDouble","toUpperCase","hsl","hwb","rgb","hexAlpha","i2","parseFloat","isNaN","rgba","percent","g","b","hsla","hwba","keyword","isArrayish","input","acceptLayer","assignLayer","TYPE_DRILL","TYPE_OUTLINE","top","bottom","viewbox","gatherLayers","findLayer","useLayer","className","class","createRect","copyPads","classPrefix","idPrefix","layerProps","layerIds","drillIds","group","mechMask","cuLayer","TYPE_COPPER","smLayer","TYPE_SOLDERMASK","ssLayer","TYPE_SILKSCREEN","spLayer","TYPE_SOLDERPASTE","outLayerId","outlineId","cfMaskId","cfMaskGroup","smMaskId","smMaskGroup","smGroupAttr","smGroupShape","makeCopy","copyOutline","wrapLayer","getScale","layerUnits","unitsCount","in","mm","allLayers","drillCount","getUniqueId","externalId","layerBox","scale","wrapConverterLayer","runParallel","runWaterfall","gerberToSvg","createStackup","getLayerValidationError","validate","filename","valid","layerErrors","validateLayersInput","stackup","layerTypes","layerTasks","makeRenderLayerTask","stackupLayers","stackupLayer","layerSide","layerType","gerberId","layerOptions","outlineGapFill","makeBaseStackupLayer"],"mappings":"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","file":"2.2860b24d78cee11b8d5e.worker.js","sourcesContent":["'use strict';\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\n\nfunction createErrorType(code, message, Base) {\n if (!Base) {\n Base = Error;\n }\n\n function getMessage(arg1, arg2, arg3) {\n if (typeof message === 'string') {\n return message;\n } else {\n return message(arg1, arg2, arg3);\n }\n }\n\n var NodeError =\n /*#__PURE__*/\n function (_Base) {\n _inheritsLoose(NodeError, _Base);\n\n function NodeError(arg1, arg2, arg3) {\n return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n }\n\n return NodeError;\n }(Base);\n\n NodeError.prototype.name = Base.name;\n NodeError.prototype.code = code;\n codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n if (Array.isArray(expected)) {\n var len = expected.length;\n expected = expected.map(function (i) {\n return String(i);\n });\n\n if (len > 2) {\n return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n } else if (len === 2) {\n return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n } else {\n return \"of \".concat(thing, \" \").concat(expected[0]);\n }\n } else {\n return \"of \".concat(thing, \" \").concat(String(expected));\n }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n if (this_len === undefined || this_len > str.length) {\n this_len = str.length;\n }\n\n return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n if (typeof start !== 'number') {\n start = 0;\n }\n\n if (start + search.length > str.length) {\n return false;\n } else {\n return str.indexOf(search, start) !== -1;\n }\n}\n\ncreateErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {\n return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n // determiner: 'must be' or 'must not be'\n var determiner;\n\n if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n determiner = 'must not be';\n expected = expected.replace(/^not /, '');\n } else {\n determiner = 'must be';\n }\n\n var msg;\n\n if (endsWith(name, ' argument')) {\n // For cases like 'first argument'\n msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n } else {\n var type = includes(name, '.') ? 'property' : 'argument';\n msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n }\n\n msg += \". Received type \".concat(typeof actual);\n return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n'use strict';\n/**/\n\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n\n for (var key in obj) {\n keys.push(key);\n }\n\n return keys;\n};\n/**/\n\n\nmodule.exports = Duplex;\n\nvar Readable = require('./_stream_readable');\n\nvar Writable = require('./_stream_writable');\n\nrequire('inherits')(Duplex, Readable);\n\n{\n // Allow the keys array to be GC'ed.\n var keys = objectKeys(Writable.prototype);\n\n for (var v = 0; v < keys.length; v++) {\n var method = keys[v];\n if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n }\n}\n\nfunction Duplex(options) {\n if (!(this instanceof Duplex)) return new Duplex(options);\n Readable.call(this, options);\n Writable.call(this, options);\n this.allowHalfOpen = true;\n\n if (options) {\n if (options.readable === false) this.readable = false;\n if (options.writable === false) this.writable = false;\n\n if (options.allowHalfOpen === false) {\n this.allowHalfOpen = false;\n this.once('end', onend);\n }\n }\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n}); // the no-half-open enforcer\n\nfunction onend() {\n // If the writable side ended, then we're ok.\n if (this._writableState.ended) return; // no more data can be written.\n // But allow more writes to happen in this tick.\n\n process.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._readableState === undefined || this._writableState === undefined) {\n return false;\n }\n\n return this._readableState.destroyed && this._writableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (this._readableState === undefined || this._writableState === undefined) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._readableState.destroyed = value;\n this._writableState.destroyed = value;\n }\n});","'use strict';\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\n\nfunction createErrorType(code, message, Base) {\n if (!Base) {\n Base = Error;\n }\n\n function getMessage(arg1, arg2, arg3) {\n if (typeof message === 'string') {\n return message;\n } else {\n return message(arg1, arg2, arg3);\n }\n }\n\n var NodeError =\n /*#__PURE__*/\n function (_Base) {\n _inheritsLoose(NodeError, _Base);\n\n function NodeError(arg1, arg2, arg3) {\n return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n }\n\n return NodeError;\n }(Base);\n\n NodeError.prototype.name = Base.name;\n NodeError.prototype.code = code;\n codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n if (Array.isArray(expected)) {\n var len = expected.length;\n expected = expected.map(function (i) {\n return String(i);\n });\n\n if (len > 2) {\n return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n } else if (len === 2) {\n return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n } else {\n return \"of \".concat(thing, \" \").concat(expected[0]);\n }\n } else {\n return \"of \".concat(thing, \" \").concat(String(expected));\n }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n if (this_len === undefined || this_len > str.length) {\n this_len = str.length;\n }\n\n return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n if (typeof start !== 'number') {\n start = 0;\n }\n\n if (start + search.length > str.length) {\n return false;\n } else {\n return str.indexOf(search, start) !== -1;\n }\n}\n\ncreateErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {\n return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n // determiner: 'must be' or 'must not be'\n var determiner;\n\n if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n determiner = 'must not be';\n expected = expected.replace(/^not /, '');\n } else {\n determiner = 'must be';\n }\n\n var msg;\n\n if (endsWith(name, ' argument')) {\n // For cases like 'first argument'\n msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n } else {\n var type = includes(name, '.') ? 'property' : 'argument';\n msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n }\n\n msg += \". Received type \".concat(typeof actual);\n return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n'use strict';\n/**/\n\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n\n for (var key in obj) {\n keys.push(key);\n }\n\n return keys;\n};\n/**/\n\n\nmodule.exports = Duplex;\n\nvar Readable = require('./_stream_readable');\n\nvar Writable = require('./_stream_writable');\n\nrequire('inherits')(Duplex, Readable);\n\n{\n // Allow the keys array to be GC'ed.\n var keys = objectKeys(Writable.prototype);\n\n for (var v = 0; v < keys.length; v++) {\n var method = keys[v];\n if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n }\n}\n\nfunction Duplex(options) {\n if (!(this instanceof Duplex)) return new Duplex(options);\n Readable.call(this, options);\n Writable.call(this, options);\n this.allowHalfOpen = true;\n\n if (options) {\n if (options.readable === false) this.readable = false;\n if (options.writable === false) this.writable = false;\n\n if (options.allowHalfOpen === false) {\n this.allowHalfOpen = false;\n this.once('end', onend);\n }\n }\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n}); // the no-half-open enforcer\n\nfunction onend() {\n // If the writable side ended, then we're ok.\n if (this._writableState.ended) return; // no more data can be written.\n // But allow more writes to happen in this tick.\n\n process.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._readableState === undefined || this._writableState === undefined) {\n return false;\n }\n\n return this._readableState.destroyed && this._writableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (this._readableState === undefined || this._writableState === undefined) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._readableState.destroyed = value;\n this._writableState.destroyed = value;\n }\n});","'use strict';\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\n\nfunction createErrorType(code, message, Base) {\n if (!Base) {\n Base = Error;\n }\n\n function getMessage(arg1, arg2, arg3) {\n if (typeof message === 'string') {\n return message;\n } else {\n return message(arg1, arg2, arg3);\n }\n }\n\n var NodeError =\n /*#__PURE__*/\n function (_Base) {\n _inheritsLoose(NodeError, _Base);\n\n function NodeError(arg1, arg2, arg3) {\n return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n }\n\n return NodeError;\n }(Base);\n\n NodeError.prototype.name = Base.name;\n NodeError.prototype.code = code;\n codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n if (Array.isArray(expected)) {\n var len = expected.length;\n expected = expected.map(function (i) {\n return String(i);\n });\n\n if (len > 2) {\n return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n } else if (len === 2) {\n return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n } else {\n return \"of \".concat(thing, \" \").concat(expected[0]);\n }\n } else {\n return \"of \".concat(thing, \" \").concat(String(expected));\n }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n if (this_len === undefined || this_len > str.length) {\n this_len = str.length;\n }\n\n return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n if (typeof start !== 'number') {\n start = 0;\n }\n\n if (start + search.length > str.length) {\n return false;\n } else {\n return str.indexOf(search, start) !== -1;\n }\n}\n\ncreateErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {\n return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n // determiner: 'must be' or 'must not be'\n var determiner;\n\n if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n determiner = 'must not be';\n expected = expected.replace(/^not /, '');\n } else {\n determiner = 'must be';\n }\n\n var msg;\n\n if (endsWith(name, ' argument')) {\n // For cases like 'first argument'\n msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n } else {\n var type = includes(name, '.') ? 'property' : 'argument';\n msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n }\n\n msg += \". Received type \".concat(typeof actual);\n return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n'use strict';\n/**/\n\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n\n for (var key in obj) {\n keys.push(key);\n }\n\n return keys;\n};\n/**/\n\n\nmodule.exports = Duplex;\n\nvar Readable = require('./_stream_readable');\n\nvar Writable = require('./_stream_writable');\n\nrequire('inherits')(Duplex, Readable);\n\n{\n // Allow the keys array to be GC'ed.\n var keys = objectKeys(Writable.prototype);\n\n for (var v = 0; v < keys.length; v++) {\n var method = keys[v];\n if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n }\n}\n\nfunction Duplex(options) {\n if (!(this instanceof Duplex)) return new Duplex(options);\n Readable.call(this, options);\n Writable.call(this, options);\n this.allowHalfOpen = true;\n\n if (options) {\n if (options.readable === false) this.readable = false;\n if (options.writable === false) this.writable = false;\n\n if (options.allowHalfOpen === false) {\n this.allowHalfOpen = false;\n this.once('end', onend);\n }\n }\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n}); // the no-half-open enforcer\n\nfunction onend() {\n // If the writable side ended, then we're ok.\n if (this._writableState.ended) return; // no more data can be written.\n // But allow more writes to happen in this tick.\n\n process.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._readableState === undefined || this._writableState === undefined) {\n return false;\n }\n\n return this._readableState.destroyed && this._writableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (this._readableState === undefined || this._writableState === undefined) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._readableState.destroyed = value;\n this._writableState.destroyed = value;\n }\n});","/**\n * lodash (Custom Build) \n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors \n * Released under MIT license \n * Based on Underscore.js 1.8.3 \n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsFinite = root.isFinite;\n\n/**\n * Checks if `value` is a finite primitive number.\n *\n * **Note:** This method is based on\n * [`Number.isFinite`](https://mdn.io/Number/isFinite).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a finite number,\n * else `false`.\n * @example\n *\n * _.isFinite(3);\n * // => true\n *\n * _.isFinite(Number.MIN_VALUE);\n * // => true\n *\n * _.isFinite(Infinity);\n * // => false\n *\n * _.isFinite('3');\n * // => false\n */\nfunction isFinite(value) {\n return typeof value == 'number' && nativeIsFinite(value);\n}\n\nmodule.exports = isFinite;\n","// helper utilities\n'use strict'\n\n// shift the decimal place to SVG coordinates (units * 1000)\n// also round to 7 decimal places\nvar shift = function(number) {\n return Math.round(10000000000 * number) / 10000000\n}\n\nvar boundingRect = function(box, fill, element) {\n return element('rect', {\n x: shift(box[0]),\n y: shift(box[1]),\n width: shift(box[2] - box[0]),\n height: shift(box[3] - box[1]),\n fill: fill,\n })\n}\n\nvar maskLayer = function(maskId, layer, element) {\n var maskUrl = 'url(#' + maskId + ')'\n\n return element('g', {mask: maskUrl}, layer)\n}\n\nvar createMask = function(maskId, box, children, element) {\n children = [boundingRect(box, '#fff', element)].concat(children)\n var attributes = {id: maskId, fill: '#000', stroke: '#000'}\n\n return element('mask', attributes, [element('g', {}, children)])\n}\n\nmodule.exports = {\n shift: shift,\n maskLayer: maskLayer,\n createMask: createMask,\n}\n","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\n\nfunction once(callback) {\n var called = false;\n return function () {\n if (called) return;\n called = true;\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n callback.apply(this, args);\n };\n}\n\nfunction noop() {}\n\nfunction isRequest(stream) {\n return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction eos(stream, opts, callback) {\n if (typeof opts === 'function') return eos(stream, null, opts);\n if (!opts) opts = {};\n callback = once(callback || noop);\n var readable = opts.readable || opts.readable !== false && stream.readable;\n var writable = opts.writable || opts.writable !== false && stream.writable;\n\n var onlegacyfinish = function onlegacyfinish() {\n if (!stream.writable) onfinish();\n };\n\n var writableEnded = stream._writableState && stream._writableState.finished;\n\n var onfinish = function onfinish() {\n writable = false;\n writableEnded = true;\n if (!readable) callback.call(stream);\n };\n\n var readableEnded = stream._readableState && stream._readableState.endEmitted;\n\n var onend = function onend() {\n readable = false;\n readableEnded = true;\n if (!writable) callback.call(stream);\n };\n\n var onerror = function onerror(err) {\n callback.call(stream, err);\n };\n\n var onclose = function onclose() {\n var err;\n\n if (readable && !readableEnded) {\n if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n\n if (writable && !writableEnded) {\n if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n };\n\n var onrequest = function onrequest() {\n stream.req.on('finish', onfinish);\n };\n\n if (isRequest(stream)) {\n stream.on('complete', onfinish);\n stream.on('abort', onclose);\n if (stream.req) onrequest();else stream.on('request', onrequest);\n } else if (writable && !stream._writableState) {\n // legacy streams\n stream.on('end', onlegacyfinish);\n stream.on('close', onlegacyfinish);\n }\n\n stream.on('end', onend);\n stream.on('finish', onfinish);\n if (opts.error !== false) stream.on('error', onerror);\n stream.on('close', onclose);\n return function () {\n stream.removeListener('complete', onfinish);\n stream.removeListener('abort', onclose);\n stream.removeListener('request', onrequest);\n if (stream.req) stream.req.removeListener('finish', onfinish);\n stream.removeListener('end', onlegacyfinish);\n stream.removeListener('close', onlegacyfinish);\n stream.removeListener('finish', onfinish);\n stream.removeListener('end', onend);\n stream.removeListener('error', onerror);\n stream.removeListener('close', onclose);\n };\n}\n\nmodule.exports = eos;","// convert a decimal number or gerber/drill coordinate into an svg coordinate\n// coordinate is 1000x the gerber unit\n'use strict'\n\nvar numIsFinite = require('lodash.isfinite')\nvar padLeft = require('lodash.padstart')\nvar padRight = require('lodash.padend')\n\n// function takes in the number string to be converted and the format object\nvar normalizeCoord = function(number, format) {\n // make sure we're dealing with a string\n if (number == null) {\n return NaN\n }\n\n var numberString = '' + number\n\n // pull out the sign and get the before and after segments ready\n var sign = '+'\n if (numberString[0] === '-' || numberString[0] === '+') {\n sign = numberString[0]\n numberString = numberString.slice(1)\n }\n\n // check if the number has a decimal point or has been explicitely flagged\n // if it does, just split by the decimal point to get leading and trailing\n var hasDecimal = numberString.indexOf('.') !== -1\n if (hasDecimal || format == null || format.zero == null) {\n return Number(sign + numberString)\n } else {\n // otherwise we need to use the number format to split up the string\n // make sure format is valid\n if (format.places == null || format.places.length !== 2) {\n return NaN\n }\n\n var leading = format.places[0]\n var trailing = format.places[1]\n if (!numIsFinite(leading) || !numIsFinite(trailing)) {\n return NaN\n }\n\n // pad according to trailing or leading zero suppression\n if (format.zero === 'T') {\n numberString = padRight(numberString, leading + trailing, '0')\n } else if (format.zero === 'L') {\n numberString = padLeft(numberString, leading + trailing, '0')\n } else {\n return NaN\n }\n }\n\n // finally, parse the numberString\n var before = numberString.slice(0, leading)\n var after = numberString.slice(leading, leading + trailing)\n return Number(sign + before + '.' + after)\n}\n\nmodule.exports = normalizeCoord\n","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\n\nfunction once(callback) {\n var called = false;\n return function () {\n if (called) return;\n called = true;\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n callback.apply(this, args);\n };\n}\n\nfunction noop() {}\n\nfunction isRequest(stream) {\n return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction eos(stream, opts, callback) {\n if (typeof opts === 'function') return eos(stream, null, opts);\n if (!opts) opts = {};\n callback = once(callback || noop);\n var readable = opts.readable || opts.readable !== false && stream.readable;\n var writable = opts.writable || opts.writable !== false && stream.writable;\n\n var onlegacyfinish = function onlegacyfinish() {\n if (!stream.writable) onfinish();\n };\n\n var writableEnded = stream._writableState && stream._writableState.finished;\n\n var onfinish = function onfinish() {\n writable = false;\n writableEnded = true;\n if (!readable) callback.call(stream);\n };\n\n var readableEnded = stream._readableState && stream._readableState.endEmitted;\n\n var onend = function onend() {\n readable = false;\n readableEnded = true;\n if (!writable) callback.call(stream);\n };\n\n var onerror = function onerror(err) {\n callback.call(stream, err);\n };\n\n var onclose = function onclose() {\n var err;\n\n if (readable && !readableEnded) {\n if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n\n if (writable && !writableEnded) {\n if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n };\n\n var onrequest = function onrequest() {\n stream.req.on('finish', onfinish);\n };\n\n if (isRequest(stream)) {\n stream.on('complete', onfinish);\n stream.on('abort', onclose);\n if (stream.req) onrequest();else stream.on('request', onrequest);\n } else if (writable && !stream._writableState) {\n // legacy streams\n stream.on('end', onlegacyfinish);\n stream.on('close', onlegacyfinish);\n }\n\n stream.on('end', onend);\n stream.on('finish', onfinish);\n if (opts.error !== false) stream.on('error', onerror);\n stream.on('close', onclose);\n return function () {\n stream.removeListener('complete', onfinish);\n stream.removeListener('abort', onclose);\n stream.removeListener('request', onrequest);\n if (stream.req) stream.req.removeListener('finish', onfinish);\n stream.removeListener('end', onlegacyfinish);\n stream.removeListener('close', onlegacyfinish);\n stream.removeListener('finish', onfinish);\n stream.removeListener('end', onend);\n stream.removeListener('error', onerror);\n stream.removeListener('close', onclose);\n };\n}\n\nmodule.exports = eos;","// bounding box utilities and helpers\n// bouding boxes are arrays of the format: [xMin, yMin, xMax, yMax]\n'use strict'\n\n// returns a new bounding box that is infinitely small and centered on nothing\nvar newBox = function() {\n return [Infinity, Infinity, -Infinity, -Infinity]\n}\n\n// adds the two bounding boxes and returns a new one\nvar add = function(box, target) {\n return [\n Math.min(box[0], target[0]),\n Math.min(box[1], target[1]),\n Math.max(box[2], target[2]),\n Math.max(box[3], target[3]),\n ]\n}\n\n// adds a point to a bounding box\nvar addPoint = function(box, point) {\n return [\n Math.min(box[0], point[0]),\n Math.min(box[1], point[1]),\n Math.max(box[2], point[0]),\n Math.max(box[3], point[1]),\n ]\n}\n\n// add a circle at (cx, cy) with radius r to box\nvar addCircle = function(box, r, cx, cy) {\n return [\n Math.min(box[0], cx - r),\n Math.min(box[1], cy - r),\n Math.max(box[2], cx + r),\n Math.max(box[3], cy + r),\n ]\n}\n\n// translate a box by a delta [x, y]\nvar translate = function(box, delta) {\n var dx = delta[0]\n var dy = delta[1]\n\n return [box[0] + dx, box[1] + dy, box[2] + dx, box[3] + dy]\n}\n\n// get the overall box if box is repeated at [x, y]\nvar repeat = function(box, repeat) {\n return add(box, translate(box, repeat))\n}\n\nmodule.exports = {\n new: newBox,\n add: add,\n addPoint: addPoint,\n addCircle: addCircle,\n translate: translate,\n repeat: repeat,\n}\n","// create an xml element string\n'use strict'\n\nvar escapeHtml = require('escape-html')\n\nmodule.exports = function createXmlString(tag, attributes, children) {\n attributes = attributes || {}\n children = children || []\n\n var start = '<' + escapeHtml(tag)\n\n var middle = Object.keys(attributes).reduce(function(result, key) {\n var value = attributes[key]\n var attr = (value != null)\n ? (' ' + escapeHtml(key) + '=\"' + escapeHtml(value) + '\"')\n : ''\n\n return result + attr\n }, '')\n\n var end = (children.length)\n ? '>' + children.join('') + ''\n : '/>'\n\n return start + middle + end\n}\n","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\n\nfunction once(callback) {\n var called = false;\n return function () {\n if (called) return;\n called = true;\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n callback.apply(this, args);\n };\n}\n\nfunction noop() {}\n\nfunction isRequest(stream) {\n return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction eos(stream, opts, callback) {\n if (typeof opts === 'function') return eos(stream, null, opts);\n if (!opts) opts = {};\n callback = once(callback || noop);\n var readable = opts.readable || opts.readable !== false && stream.readable;\n var writable = opts.writable || opts.writable !== false && stream.writable;\n\n var onlegacyfinish = function onlegacyfinish() {\n if (!stream.writable) onfinish();\n };\n\n var writableEnded = stream._writableState && stream._writableState.finished;\n\n var onfinish = function onfinish() {\n writable = false;\n writableEnded = true;\n if (!readable) callback.call(stream);\n };\n\n var readableEnded = stream._readableState && stream._readableState.endEmitted;\n\n var onend = function onend() {\n readable = false;\n readableEnded = true;\n if (!writable) callback.call(stream);\n };\n\n var onerror = function onerror(err) {\n callback.call(stream, err);\n };\n\n var onclose = function onclose() {\n var err;\n\n if (readable && !readableEnded) {\n if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n\n if (writable && !writableEnded) {\n if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n };\n\n var onrequest = function onrequest() {\n stream.req.on('finish', onfinish);\n };\n\n if (isRequest(stream)) {\n stream.on('complete', onfinish);\n stream.on('abort', onclose);\n if (stream.req) onrequest();else stream.on('request', onrequest);\n } else if (writable && !stream._writableState) {\n // legacy streams\n stream.on('end', onlegacyfinish);\n stream.on('close', onlegacyfinish);\n }\n\n stream.on('end', onend);\n stream.on('finish', onfinish);\n if (opts.error !== false) stream.on('error', onerror);\n stream.on('close', onclose);\n return function () {\n stream.removeListener('complete', onfinish);\n stream.removeListener('abort', onclose);\n stream.removeListener('request', onrequest);\n if (stream.req) stream.req.removeListener('finish', onfinish);\n stream.removeListener('end', onlegacyfinish);\n stream.removeListener('close', onlegacyfinish);\n stream.removeListener('finish', onfinish);\n stream.removeListener('end', onend);\n stream.removeListener('error', onerror);\n stream.removeListener('close', onclose);\n };\n}\n\nmodule.exports = eos;","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n'use strict';\n\nmodule.exports = Readable;\n/**/\n\nvar Duplex;\n/**/\n\nReadable.ReadableState = ReadableState;\n/**/\n\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n return emitter.listeners(type).length;\n};\n/**/\n\n/**/\n\n\nvar Stream = require('./internal/streams/stream');\n/**/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/**/\n\n\nvar debugUtil = require('util');\n\nvar debug;\n\nif (debugUtil && debugUtil.debuglog) {\n debug = debugUtil.debuglog('stream');\n} else {\n debug = function debug() {};\n}\n/**/\n\n\nvar BufferList = require('./internal/streams/buffer_list');\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;\n\nvar _require2 = require('../experimentalWarning'),\n emitExperimentalWarning = _require2.emitExperimentalWarning; // Lazy loaded to improve the startup performance.\n\n\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\n\nrequire('inherits')(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n // Sadly this is not cacheable as some libraries bundle their own\n // event emitter implementation with them.\n if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any\n // userland ones. NEVER DO THIS. This is here only because this code needs\n // to continue to work with older versions of Node.js that do not include\n // the prependListener() method. The goal is to eventually remove this hack.\n\n if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream, isDuplex) {\n Duplex = Duplex || require('./_stream_duplex');\n options = options || {}; // Duplex streams are both readable and writable, but share\n // the same options object.\n // However, some cases require setting options to different\n // values for the readable and the writable sides of the duplex stream.\n // These options can be provided separately as readableXXX and writableXXX.\n\n if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to\n // make all the buffer merging and length checks go away\n\n this.objectMode = !!options.objectMode;\n if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer\n // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n\n this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the\n // linked list can remove elements from the beginning faster than\n // array.shift()\n\n this.buffer = new BufferList();\n this.length = 0;\n this.pipes = null;\n this.pipesCount = 0;\n this.flowing = null;\n this.ended = false;\n this.endEmitted = false;\n this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted\n // immediately, or on a later tick. We set this to true at first, because\n // any actions that shouldn't happen until \"later\" should generally also\n // not happen before the first read call.\n\n this.sync = true; // whenever we return null, then we set a flag to say\n // that we're awaiting a 'readable' event emission.\n\n this.needReadable = false;\n this.emittedReadable = false;\n this.readableListening = false;\n this.resumeScheduled = false;\n this.paused = true; // Should close be emitted on destroy. Defaults to true.\n\n this.emitClose = options.emitClose !== false; // has it been destroyed\n\n this.destroyed = false; // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n\n this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s\n\n this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled\n\n this.readingMore = false;\n this.decoder = null;\n this.encoding = null;\n\n if (options.encoding) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n this.decoder = new StringDecoder(options.encoding);\n this.encoding = options.encoding;\n }\n}\n\nfunction Readable(options) {\n Duplex = Duplex || require('./_stream_duplex');\n if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside\n // the ReadableState constructor, at least with V8 6.5\n\n var isDuplex = this instanceof Duplex;\n this._readableState = new ReadableState(options, this, isDuplex); // legacy\n\n this.readable = true;\n\n if (options) {\n if (typeof options.read === 'function') this._read = options.read;\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n }\n\n Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._readableState === undefined) {\n return false;\n }\n\n return this._readableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._readableState) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._readableState.destroyed = value;\n }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\n\nReadable.prototype._destroy = function (err, cb) {\n cb(err);\n}; // Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\n\n\nReadable.prototype.push = function (chunk, encoding) {\n var state = this._readableState;\n var skipChunkCheck;\n\n if (!state.objectMode) {\n if (typeof chunk === 'string') {\n encoding = encoding || state.defaultEncoding;\n\n if (encoding !== state.encoding) {\n chunk = Buffer.from(chunk, encoding);\n encoding = '';\n }\n\n skipChunkCheck = true;\n }\n } else {\n skipChunkCheck = true;\n }\n\n return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n}; // Unshift should *always* be something directly out of read()\n\n\nReadable.prototype.unshift = function (chunk) {\n return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n debug('readableAddChunk', chunk);\n var state = stream._readableState;\n\n if (chunk === null) {\n state.reading = false;\n onEofChunk(stream, state);\n } else {\n var er;\n if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n\n if (er) {\n stream.emit('error', er);\n } else if (state.objectMode || chunk && chunk.length > 0) {\n if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (addToFront) {\n if (state.endEmitted) stream.emit('error', new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n } else if (state.ended) {\n stream.emit('error', new ERR_STREAM_PUSH_AFTER_EOF());\n } else if (state.destroyed) {\n return false;\n } else {\n state.reading = false;\n\n if (state.decoder && !encoding) {\n chunk = state.decoder.write(chunk);\n if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n } else {\n addChunk(stream, state, chunk, false);\n }\n }\n } else if (!addToFront) {\n state.reading = false;\n maybeReadMore(stream, state);\n }\n } // We can push more data if we are below the highWaterMark.\n // Also, if we have no data yet, we can stand some more bytes.\n // This is to work around cases where hwm=0, such as the repl.\n\n\n return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n if (state.flowing && state.length === 0 && !state.sync) {\n state.awaitDrain = 0;\n stream.emit('data', chunk);\n } else {\n // update the buffer info.\n state.length += state.objectMode ? 1 : chunk.length;\n if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n if (state.needReadable) emitReadable(stream);\n }\n\n maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n var er;\n\n if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n }\n\n return er;\n}\n\nReadable.prototype.isPaused = function () {\n return this._readableState.flowing === false;\n}; // backwards compatibility.\n\n\nReadable.prototype.setEncoding = function (enc) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n this._readableState.decoder = new StringDecoder(enc); // if setEncoding(null), decoder.encoding equals utf8\n\n this._readableState.encoding = this._readableState.decoder.encoding;\n return this;\n}; // Don't raise the hwm > 8MB\n\n\nvar MAX_HWM = 0x800000;\n\nfunction computeNewHighWaterMark(n) {\n if (n >= MAX_HWM) {\n n = MAX_HWM;\n } else {\n // Get the next highest power of 2 to prevent increasing hwm excessively in\n // tiny amounts\n n--;\n n |= n >>> 1;\n n |= n >>> 2;\n n |= n >>> 4;\n n |= n >>> 8;\n n |= n >>> 16;\n n++;\n }\n\n return n;\n} // This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\n\nfunction howMuchToRead(n, state) {\n if (n <= 0 || state.length === 0 && state.ended) return 0;\n if (state.objectMode) return 1;\n\n if (n !== n) {\n // Only flow one buffer at a time\n if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n } // If we're asking for more than the current hwm, then raise the hwm.\n\n\n if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n if (n <= state.length) return n; // Don't have enough\n\n if (!state.ended) {\n state.needReadable = true;\n return 0;\n }\n\n return state.length;\n} // you can override either this method, or the async _read(n) below.\n\n\nReadable.prototype.read = function (n) {\n debug('read', n);\n n = parseInt(n, 10);\n var state = this._readableState;\n var nOrig = n;\n if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we\n // already have a bunch of data in the buffer, then just trigger\n // the 'readable' event and move on.\n\n if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n debug('read: emitReadable', state.length, state.ended);\n if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n return null;\n }\n\n n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.\n\n if (n === 0 && state.ended) {\n if (state.length === 0) endReadable(this);\n return null;\n } // All the actual chunk generation logic needs to be\n // *below* the call to _read. The reason is that in certain\n // synthetic stream cases, such as passthrough streams, _read\n // may be a completely synchronous operation which may change\n // the state of the read buffer, providing enough data when\n // before there was *not* enough.\n //\n // So, the steps are:\n // 1. Figure out what the state of things will be after we do\n // a read from the buffer.\n //\n // 2. If that resulting state will trigger a _read, then call _read.\n // Note that this may be asynchronous, or synchronous. Yes, it is\n // deeply ugly to write APIs this way, but that still doesn't mean\n // that the Readable class should behave improperly, as streams are\n // designed to be sync/async agnostic.\n // Take note if the _read call is sync or async (ie, if the read call\n // has returned yet), so that we know whether or not it's safe to emit\n // 'readable' etc.\n //\n // 3. Actually pull the requested chunks out of the buffer and return.\n // if we need a readable event, then we need to do some reading.\n\n\n var doRead = state.needReadable;\n debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some\n\n if (state.length === 0 || state.length - n < state.highWaterMark) {\n doRead = true;\n debug('length less than watermark', doRead);\n } // however, if we've ended, then there's no point, and if we're already\n // reading, then it's unnecessary.\n\n\n if (state.ended || state.reading) {\n doRead = false;\n debug('reading or ended', doRead);\n } else if (doRead) {\n debug('do read');\n state.reading = true;\n state.sync = true; // if the length is currently zero, then we *need* a readable event.\n\n if (state.length === 0) state.needReadable = true; // call internal read method\n\n this._read(state.highWaterMark);\n\n state.sync = false; // If _read pushed data synchronously, then `reading` will be false,\n // and we need to re-evaluate how much data we can return to the user.\n\n if (!state.reading) n = howMuchToRead(nOrig, state);\n }\n\n var ret;\n if (n > 0) ret = fromList(n, state);else ret = null;\n\n if (ret === null) {\n state.needReadable = true;\n n = 0;\n } else {\n state.length -= n;\n state.awaitDrain = 0;\n }\n\n if (state.length === 0) {\n // If we have nothing in the buffer, then we want to know\n // as soon as we *do* get something into the buffer.\n if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.\n\n if (nOrig !== n && state.ended) endReadable(this);\n }\n\n if (ret !== null) this.emit('data', ret);\n return ret;\n};\n\nfunction onEofChunk(stream, state) {\n if (state.ended) return;\n\n if (state.decoder) {\n var chunk = state.decoder.end();\n\n if (chunk && chunk.length) {\n state.buffer.push(chunk);\n state.length += state.objectMode ? 1 : chunk.length;\n }\n }\n\n state.ended = true;\n\n if (state.sync) {\n // if we are sync, wait until next tick to emit the data.\n // Otherwise we risk emitting data in the flow()\n // the readable code triggers during a read() call\n emitReadable(stream);\n } else {\n // emit 'readable' now to make sure it gets picked up.\n state.needReadable = false;\n\n if (!state.emittedReadable) {\n state.emittedReadable = true;\n emitReadable_(stream);\n }\n }\n} // Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow. This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\n\n\nfunction emitReadable(stream) {\n var state = stream._readableState;\n state.needReadable = false;\n\n if (!state.emittedReadable) {\n debug('emitReadable', state.flowing);\n state.emittedReadable = true;\n process.nextTick(emitReadable_, stream);\n }\n}\n\nfunction emitReadable_(stream) {\n var state = stream._readableState;\n debug('emitReadable_', state.destroyed, state.length, state.ended);\n\n if (!state.destroyed && (state.length || state.ended)) {\n stream.emit('readable');\n } // The stream needs another readable event if\n // 1. It is not flowing, as the flow mechanism will take\n // care of it.\n // 2. It is not ended.\n // 3. It is below the highWaterMark, so we can schedule\n // another readable later.\n\n\n state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n flow(stream);\n} // at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data. that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\n\n\nfunction maybeReadMore(stream, state) {\n if (!state.readingMore) {\n state.readingMore = true;\n process.nextTick(maybeReadMore_, stream, state);\n }\n}\n\nfunction maybeReadMore_(stream, state) {\n // Attempt to read more data if we should.\n //\n // The conditions for reading more data are (one of):\n // - Not enough data buffered (state.length < state.highWaterMark). The loop\n // is responsible for filling the buffer with enough data if such data\n // is available. If highWaterMark is 0 and we are not in the flowing mode\n // we should _not_ attempt to buffer any extra data. We'll get more data\n // when the stream consumer calls read() instead.\n // - No data in the buffer, and the stream is in flowing mode. In this mode\n // the loop below is responsible for ensuring read() is called. Failing to\n // call read here would abort the flow and there's no other mechanism for\n // continuing the flow if the stream consumer has just subscribed to the\n // 'data' event.\n //\n // In addition to the above conditions to keep reading data, the following\n // conditions prevent the data from being read:\n // - The stream has ended (state.ended).\n // - There is already a pending 'read' operation (state.reading). This is a\n // case where the the stream has called the implementation defined _read()\n // method, but they are processing the call asynchronously and have _not_\n // called push() with new data. In this case we skip performing more\n // read()s. The execution ends in this method again after the _read() ends\n // up calling push() with more data.\n while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n var len = state.length;\n debug('maybeReadMore read 0');\n stream.read(0);\n if (len === state.length) // didn't get any data, stop spinning.\n break;\n }\n\n state.readingMore = false;\n} // abstract method. to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\n\n\nReadable.prototype._read = function (n) {\n this.emit('error', new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n var src = this;\n var state = this._readableState;\n\n switch (state.pipesCount) {\n case 0:\n state.pipes = dest;\n break;\n\n case 1:\n state.pipes = [state.pipes, dest];\n break;\n\n default:\n state.pipes.push(dest);\n break;\n }\n\n state.pipesCount += 1;\n debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n var endFn = doEnd ? onend : unpipe;\n if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\n dest.on('unpipe', onunpipe);\n\n function onunpipe(readable, unpipeInfo) {\n debug('onunpipe');\n\n if (readable === src) {\n if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n unpipeInfo.hasUnpiped = true;\n cleanup();\n }\n }\n }\n\n function onend() {\n debug('onend');\n dest.end();\n } // when the dest drains, it reduces the awaitDrain counter\n // on the source. This would be more elegant with a .once()\n // handler in flow(), but adding and removing repeatedly is\n // too slow.\n\n\n var ondrain = pipeOnDrain(src);\n dest.on('drain', ondrain);\n var cleanedUp = false;\n\n function cleanup() {\n debug('cleanup'); // cleanup event handlers once the pipe is broken\n\n dest.removeListener('close', onclose);\n dest.removeListener('finish', onfinish);\n dest.removeListener('drain', ondrain);\n dest.removeListener('error', onerror);\n dest.removeListener('unpipe', onunpipe);\n src.removeListener('end', onend);\n src.removeListener('end', unpipe);\n src.removeListener('data', ondata);\n cleanedUp = true; // if the reader is waiting for a drain event from this\n // specific writer, then it would cause it to never start\n // flowing again.\n // So, if this is awaiting a drain, then we just call it now.\n // If we don't know, then assume that we are waiting for one.\n\n if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n }\n\n src.on('data', ondata);\n\n function ondata(chunk) {\n debug('ondata');\n var ret = dest.write(chunk);\n debug('dest.write', ret);\n\n if (ret === false) {\n // If the user unpiped during `dest.write()`, it is possible\n // to get stuck in a permanently paused state if that write\n // also returned false.\n // => Check whether `dest` is still a piping destination.\n if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n debug('false write response, pause', state.awaitDrain);\n state.awaitDrain++;\n }\n\n src.pause();\n }\n } // if the dest has an error, then stop piping into it.\n // however, don't suppress the throwing behavior for this.\n\n\n function onerror(er) {\n debug('onerror', er);\n unpipe();\n dest.removeListener('error', onerror);\n if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n } // Make sure our error handler is attached before userland ones.\n\n\n prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.\n\n function onclose() {\n dest.removeListener('finish', onfinish);\n unpipe();\n }\n\n dest.once('close', onclose);\n\n function onfinish() {\n debug('onfinish');\n dest.removeListener('close', onclose);\n unpipe();\n }\n\n dest.once('finish', onfinish);\n\n function unpipe() {\n debug('unpipe');\n src.unpipe(dest);\n } // tell the dest that it's being piped to\n\n\n dest.emit('pipe', src); // start the flow if it hasn't been started already.\n\n if (!state.flowing) {\n debug('pipe resume');\n src.resume();\n }\n\n return dest;\n};\n\nfunction pipeOnDrain(src) {\n return function pipeOnDrainFunctionResult() {\n var state = src._readableState;\n debug('pipeOnDrain', state.awaitDrain);\n if (state.awaitDrain) state.awaitDrain--;\n\n if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n state.flowing = true;\n flow(src);\n }\n };\n}\n\nReadable.prototype.unpipe = function (dest) {\n var state = this._readableState;\n var unpipeInfo = {\n hasUnpiped: false\n }; // if we're not piping anywhere, then do nothing.\n\n if (state.pipesCount === 0) return this; // just one destination. most common case.\n\n if (state.pipesCount === 1) {\n // passed in one, but it's not the right one.\n if (dest && dest !== state.pipes) return this;\n if (!dest) dest = state.pipes; // got a match.\n\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n if (dest) dest.emit('unpipe', this, unpipeInfo);\n return this;\n } // slow case. multiple pipe destinations.\n\n\n if (!dest) {\n // remove all.\n var dests = state.pipes;\n var len = state.pipesCount;\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n\n for (var i = 0; i < len; i++) {\n dests[i].emit('unpipe', this, {\n hasUnpiped: false\n });\n }\n\n return this;\n } // try to find the right one.\n\n\n var index = indexOf(state.pipes, dest);\n if (index === -1) return this;\n state.pipes.splice(index, 1);\n state.pipesCount -= 1;\n if (state.pipesCount === 1) state.pipes = state.pipes[0];\n dest.emit('unpipe', this, unpipeInfo);\n return this;\n}; // set up data events if they are asked for\n// Ensure readable listeners eventually get something\n\n\nReadable.prototype.on = function (ev, fn) {\n var res = Stream.prototype.on.call(this, ev, fn);\n var state = this._readableState;\n\n if (ev === 'data') {\n // update readableListening so that resume() may be a no-op\n // a few lines down. This is needed to support once('readable').\n state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused\n\n if (state.flowing !== false) this.resume();\n } else if (ev === 'readable') {\n if (!state.endEmitted && !state.readableListening) {\n state.readableListening = state.needReadable = true;\n state.flowing = false;\n state.emittedReadable = false;\n debug('on readable', state.length, state.reading);\n\n if (state.length) {\n emitReadable(this);\n } else if (!state.reading) {\n process.nextTick(nReadingNextTick, this);\n }\n }\n }\n\n return res;\n};\n\nReadable.prototype.addListener = Readable.prototype.on;\n\nReadable.prototype.removeListener = function (ev, fn) {\n var res = Stream.prototype.removeListener.call(this, ev, fn);\n\n if (ev === 'readable') {\n // We need to check if there is someone still listening to\n // readable and reset the state. However this needs to happen\n // after readable has been emitted but before I/O (nextTick) to\n // support once('readable', fn) cycles. This means that calling\n // resume within the same tick will have no\n // effect.\n process.nextTick(updateReadableListening, this);\n }\n\n return res;\n};\n\nReadable.prototype.removeAllListeners = function (ev) {\n var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n\n if (ev === 'readable' || ev === undefined) {\n // We need to check if there is someone still listening to\n // readable and reset the state. However this needs to happen\n // after readable has been emitted but before I/O (nextTick) to\n // support once('readable', fn) cycles. This means that calling\n // resume within the same tick will have no\n // effect.\n process.nextTick(updateReadableListening, this);\n }\n\n return res;\n};\n\nfunction updateReadableListening(self) {\n var state = self._readableState;\n state.readableListening = self.listenerCount('readable') > 0;\n\n if (state.resumeScheduled && !state.paused) {\n // flowing needs to be set to true now, otherwise\n // the upcoming resume will not flow.\n state.flowing = true; // crude way to check if we should resume\n } else if (self.listenerCount('data') > 0) {\n self.resume();\n }\n}\n\nfunction nReadingNextTick(self) {\n debug('readable nexttick read 0');\n self.read(0);\n} // pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\n\n\nReadable.prototype.resume = function () {\n var state = this._readableState;\n\n if (!state.flowing) {\n debug('resume'); // we flow only if there is no one listening\n // for readable, but we still have to call\n // resume()\n\n state.flowing = !state.readableListening;\n resume(this, state);\n }\n\n state.paused = false;\n return this;\n};\n\nfunction resume(stream, state) {\n if (!state.resumeScheduled) {\n state.resumeScheduled = true;\n process.nextTick(resume_, stream, state);\n }\n}\n\nfunction resume_(stream, state) {\n debug('resume', state.reading);\n\n if (!state.reading) {\n stream.read(0);\n }\n\n state.resumeScheduled = false;\n stream.emit('resume');\n flow(stream);\n if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n debug('call pause flowing=%j', this._readableState.flowing);\n\n if (this._readableState.flowing !== false) {\n debug('pause');\n this._readableState.flowing = false;\n this.emit('pause');\n }\n\n this._readableState.paused = true;\n return this;\n};\n\nfunction flow(stream) {\n var state = stream._readableState;\n debug('flow', state.flowing);\n\n while (state.flowing && stream.read() !== null) {\n ;\n }\n} // wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\n\n\nReadable.prototype.wrap = function (stream) {\n var _this = this;\n\n var state = this._readableState;\n var paused = false;\n stream.on('end', function () {\n debug('wrapped end');\n\n if (state.decoder && !state.ended) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length) _this.push(chunk);\n }\n\n _this.push(null);\n });\n stream.on('data', function (chunk) {\n debug('wrapped data');\n if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode\n\n if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n var ret = _this.push(chunk);\n\n if (!ret) {\n paused = true;\n stream.pause();\n }\n }); // proxy all the other methods.\n // important when wrapping filters and duplexes.\n\n for (var i in stream) {\n if (this[i] === undefined && typeof stream[i] === 'function') {\n this[i] = function methodWrap(method) {\n return function methodWrapReturnFunction() {\n return stream[method].apply(stream, arguments);\n };\n }(i);\n }\n } // proxy certain important events.\n\n\n for (var n = 0; n < kProxyEvents.length; n++) {\n stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n } // when we try to consume some more bytes, simply unpause the\n // underlying stream.\n\n\n this._read = function (n) {\n debug('wrapped _read', n);\n\n if (paused) {\n paused = false;\n stream.resume();\n }\n };\n\n return this;\n};\n\nif (typeof Symbol === 'function') {\n Readable.prototype[Symbol.asyncIterator] = function () {\n emitExperimentalWarning('Readable[Symbol.asyncIterator]');\n\n if (createReadableStreamAsyncIterator === undefined) {\n createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n }\n\n return createReadableStreamAsyncIterator(this);\n };\n}\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.highWaterMark;\n }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState && this._readableState.buffer;\n }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.flowing;\n },\n set: function set(state) {\n if (this._readableState) {\n this._readableState.flowing = state;\n }\n }\n}); // exposed for testing purposes only.\n\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.length;\n }\n}); // Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\nfunction fromList(n, state) {\n // nothing buffered\n if (state.length === 0) return null;\n var ret;\n if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n // read it all, truncate the list\n if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);\n state.buffer.clear();\n } else {\n // read part of list\n ret = state.buffer.consume(n, state.decoder);\n }\n return ret;\n}\n\nfunction endReadable(stream) {\n var state = stream._readableState;\n debug('endReadable', state.endEmitted);\n\n if (!state.endEmitted) {\n state.ended = true;\n process.nextTick(endReadableNT, state, stream);\n }\n}\n\nfunction endReadableNT(state, stream) {\n debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.\n\n if (!state.endEmitted && state.length === 0) {\n state.endEmitted = true;\n stream.readable = false;\n stream.emit('end');\n }\n}\n\nfunction indexOf(xs, x) {\n for (var i = 0, l = xs.length; i < l; i++) {\n if (xs[i] === x) return i;\n }\n\n return -1;\n}","module.exports = require('events').EventEmitter;\n","'use strict'; // undocumented cb() API, needed for core, not for public API\n\nfunction destroy(err, cb) {\n var _this = this;\n\n var readableDestroyed = this._readableState && this._readableState.destroyed;\n var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n if (readableDestroyed || writableDestroyed) {\n if (cb) {\n cb(err);\n } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n process.nextTick(emitErrorNT, this, err);\n }\n\n return this;\n } // we set destroyed to true before firing error callbacks in order\n // to make it re-entrance safe in case destroy() is called within callbacks\n\n\n if (this._readableState) {\n this._readableState.destroyed = true;\n } // if this is a duplex stream mark the writable part as destroyed as well\n\n\n if (this._writableState) {\n this._writableState.destroyed = true;\n }\n\n this._destroy(err || null, function (err) {\n if (!cb && err) {\n process.nextTick(emitErrorAndCloseNT, _this, err);\n\n if (_this._writableState) {\n _this._writableState.errorEmitted = true;\n }\n } else if (cb) {\n process.nextTick(emitCloseNT, _this);\n cb(err);\n } else {\n process.nextTick(emitCloseNT, _this);\n }\n });\n\n return this;\n}\n\nfunction emitErrorAndCloseNT(self, err) {\n emitErrorNT(self, err);\n emitCloseNT(self);\n}\n\nfunction emitCloseNT(self) {\n if (self._writableState && !self._writableState.emitClose) return;\n if (self._readableState && !self._readableState.emitClose) return;\n self.emit('close');\n}\n\nfunction undestroy() {\n if (this._readableState) {\n this._readableState.destroyed = false;\n this._readableState.reading = false;\n this._readableState.ended = false;\n this._readableState.endEmitted = false;\n }\n\n if (this._writableState) {\n this._writableState.destroyed = false;\n this._writableState.ended = false;\n this._writableState.ending = false;\n this._writableState.finalCalled = false;\n this._writableState.prefinished = false;\n this._writableState.finished = false;\n this._writableState.errorEmitted = false;\n }\n}\n\nfunction emitErrorNT(self, err) {\n self.emit('error', err);\n}\n\nmodule.exports = {\n destroy: destroy,\n undestroy: undestroy\n};","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\n\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\n\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n\n if (hwm != null) {\n if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n var name = isDuplex ? duplexKey : 'highWaterMark';\n throw new ERR_INVALID_OPT_VALUE(name, hwm);\n }\n\n return Math.floor(hwm);\n } // Default value\n\n\n return state.objectMode ? 16 : 16 * 1024;\n}\n\nmodule.exports = {\n getHighWaterMark: getHighWaterMark\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n'use strict';\n\nmodule.exports = Writable;\n/* */\n\nfunction WriteReq(chunk, encoding, cb) {\n this.chunk = chunk;\n this.encoding = encoding;\n this.callback = cb;\n this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n var _this = this;\n\n this.next = null;\n this.entry = null;\n\n this.finish = function () {\n onCorkedFinish(_this, state);\n };\n}\n/* */\n\n/**/\n\n\nvar Duplex;\n/**/\n\nWritable.WritableState = WritableState;\n/**/\n\nvar internalUtil = {\n deprecate: require('util-deprecate')\n};\n/**/\n\n/**/\n\nvar Stream = require('./internal/streams/stream');\n/**/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n Duplex = Duplex || require('./_stream_duplex');\n options = options || {}; // Duplex streams are both readable and writable, but share\n // the same options object.\n // However, some cases require setting options to different\n // values for the readable and the writable sides of the duplex stream,\n // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n\n if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n // contains buffers or objects.\n\n this.objectMode = !!options.objectMode;\n if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false\n // Note: 0 is a valid value, means that we always return false if\n // the entire buffer is not flushed immediately on write()\n\n this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n this.finalCalled = false; // drain event flag.\n\n this.needDrain = false; // at the start of calling end()\n\n this.ending = false; // when end() has been called, and returned\n\n this.ended = false; // when 'finish' is emitted\n\n this.finished = false; // has it been destroyed\n\n this.destroyed = false; // should we decode strings into buffers before passing to _write?\n // this is here so that some node-core streams can optimize string\n // handling at a lower level.\n\n var noDecode = options.decodeStrings === false;\n this.decodeStrings = !noDecode; // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n\n this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement\n // of how much we're waiting to get pushed to some underlying\n // socket or file.\n\n this.length = 0; // a flag to see when we're in the middle of a write.\n\n this.writing = false; // when true all writes will be buffered until .uncork() call\n\n this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,\n // or on a later tick. We set this to true at first, because any\n // actions that shouldn't happen until \"later\" should generally also\n // not happen before the first write call.\n\n this.sync = true; // a flag to know if we're processing previously buffered items, which\n // may call the _write() callback in the same tick, so that we don't\n // end up in an overlapped onwrite situation.\n\n this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n this.onwrite = function (er) {\n onwrite(stream, er);\n }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n this.writecb = null; // the amount that is being written when _write is called.\n\n this.writelen = 0;\n this.bufferedRequest = null;\n this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n // this must be 0 before 'finish' can be emitted\n\n this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n // This is relevant for synchronous Transform streams\n\n this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n this.emitClose = options.emitClose !== false; // count buffered requests\n\n this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n // one allocated and free to use, and we maintain at most two\n\n this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n var current = this.bufferedRequest;\n var out = [];\n\n while (current) {\n out.push(current);\n current = current.next;\n }\n\n return out;\n};\n\n(function () {\n try {\n Object.defineProperty(WritableState.prototype, 'buffer', {\n get: internalUtil.deprecate(function writableStateBufferGetter() {\n return this.getBuffer();\n }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n });\n } catch (_) {}\n})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n realHasInstance = Function.prototype[Symbol.hasInstance];\n Object.defineProperty(Writable, Symbol.hasInstance, {\n value: function value(object) {\n if (realHasInstance.call(this, object)) return true;\n if (this !== Writable) return false;\n return object && object._writableState instanceof WritableState;\n }\n });\n} else {\n realHasInstance = function realHasInstance(object) {\n return object instanceof this;\n };\n}\n\nfunction Writable(options) {\n Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.\n // `realHasInstance` is necessary because using plain `instanceof`\n // would return false, as no `_writableState` property is attached.\n // Trying to use the custom `instanceof` for Writable here will also break the\n // Node.js LazyTransform implementation, which has a non-trivial getter for\n // `_writableState` that would lead to infinite recursion.\n // Checking for a Stream.Duplex instance is faster here instead of inside\n // the WritableState constructor, at least with V8 6.5\n\n var isDuplex = this instanceof Duplex;\n if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n this._writableState = new WritableState(options, this, isDuplex); // legacy.\n\n this.writable = true;\n\n if (options) {\n if (typeof options.write === 'function') this._write = options.write;\n if (typeof options.writev === 'function') this._writev = options.writev;\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n if (typeof options.final === 'function') this._final = options.final;\n }\n\n Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n this.emit('error', new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n stream.emit('error', er);\n process.nextTick(cb, er);\n} // Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n var er;\n\n if (chunk === null) {\n er = new ERR_STREAM_NULL_VALUES();\n } else if (typeof chunk !== 'string' && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n }\n\n if (er) {\n stream.emit('error', er);\n process.nextTick(cb, er);\n return false;\n }\n\n return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n var state = this._writableState;\n var ret = false;\n\n var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n if (isBuf && !Buffer.isBuffer(chunk)) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n if (typeof cb !== 'function') cb = nop;\n if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n state.pendingcb++;\n ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n }\n return ret;\n};\n\nWritable.prototype.cork = function () {\n this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n var state = this._writableState;\n\n if (state.corked) {\n state.corked--;\n if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n // node::ParseEncoding() requires lower case.\n if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n this._writableState.defaultEncoding = encoding;\n return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n});\n\nfunction decodeChunk(state, chunk, encoding) {\n if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n chunk = Buffer.from(chunk, encoding);\n }\n\n return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n}); // if we're already writing something, then just put this\n// in the queue, and wait our turn. Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n if (!isBuf) {\n var newChunk = decodeChunk(state, chunk, encoding);\n\n if (chunk !== newChunk) {\n isBuf = true;\n encoding = 'buffer';\n chunk = newChunk;\n }\n }\n\n var len = state.objectMode ? 1 : chunk.length;\n state.length += len;\n var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\n if (!ret) state.needDrain = true;\n\n if (state.writing || state.corked) {\n var last = state.lastBufferedRequest;\n state.lastBufferedRequest = {\n chunk: chunk,\n encoding: encoding,\n isBuf: isBuf,\n callback: cb,\n next: null\n };\n\n if (last) {\n last.next = state.lastBufferedRequest;\n } else {\n state.bufferedRequest = state.lastBufferedRequest;\n }\n\n state.bufferedRequestCount += 1;\n } else {\n doWrite(stream, state, false, len, chunk, encoding, cb);\n }\n\n return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n state.writelen = len;\n state.writecb = cb;\n state.writing = true;\n state.sync = true;\n if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n --state.pendingcb;\n\n if (sync) {\n // defer the callback if we are being called synchronously\n // to avoid piling up things on the stack\n process.nextTick(cb, er); // this can emit finish, and it will always happen\n // after error\n\n process.nextTick(finishMaybe, stream, state);\n stream._writableState.errorEmitted = true;\n stream.emit('error', er);\n } else {\n // the caller expect this to happen before if\n // it is async\n cb(er);\n stream._writableState.errorEmitted = true;\n stream.emit('error', er); // this can emit finish, but finish must\n // always follow error\n\n finishMaybe(stream, state);\n }\n}\n\nfunction onwriteStateUpdate(state) {\n state.writing = false;\n state.writecb = null;\n state.length -= state.writelen;\n state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n var state = stream._writableState;\n var sync = state.sync;\n var cb = state.writecb;\n if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n onwriteStateUpdate(state);\n if (er) onwriteError(stream, state, sync, er, cb);else {\n // Check if we're actually ready to finish, but don't emit yet\n var finished = needFinish(state) || stream.destroyed;\n\n if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n clearBuffer(stream, state);\n }\n\n if (sync) {\n process.nextTick(afterWrite, stream, state, finished, cb);\n } else {\n afterWrite(stream, state, finished, cb);\n }\n }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n if (!finished) onwriteDrain(stream, state);\n state.pendingcb--;\n cb();\n finishMaybe(stream, state);\n} // Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\n\n\nfunction onwriteDrain(stream, state) {\n if (state.length === 0 && state.needDrain) {\n state.needDrain = false;\n stream.emit('drain');\n }\n} // if there's something in the buffer waiting, then process it\n\n\nfunction clearBuffer(stream, state) {\n state.bufferProcessing = true;\n var entry = state.bufferedRequest;\n\n if (stream._writev && entry && entry.next) {\n // Fast case, write everything using _writev()\n var l = state.bufferedRequestCount;\n var buffer = new Array(l);\n var holder = state.corkedRequestsFree;\n holder.entry = entry;\n var count = 0;\n var allBuffers = true;\n\n while (entry) {\n buffer[count] = entry;\n if (!entry.isBuf) allBuffers = false;\n entry = entry.next;\n count += 1;\n }\n\n buffer.allBuffers = allBuffers;\n doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n // as the hot path ends with doWrite\n\n state.pendingcb++;\n state.lastBufferedRequest = null;\n\n if (holder.next) {\n state.corkedRequestsFree = holder.next;\n holder.next = null;\n } else {\n state.corkedRequestsFree = new CorkedRequest(state);\n }\n\n state.bufferedRequestCount = 0;\n } else {\n // Slow case, write chunks one-by-one\n while (entry) {\n var chunk = entry.chunk;\n var encoding = entry.encoding;\n var cb = entry.callback;\n var len = state.objectMode ? 1 : chunk.length;\n doWrite(stream, state, false, len, chunk, encoding, cb);\n entry = entry.next;\n state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then\n // it means that we need to wait until it does.\n // also, that means that the chunk and cb are currently\n // being processed, so move the buffer counter past them.\n\n if (state.writing) {\n break;\n }\n }\n\n if (entry === null) state.lastBufferedRequest = null;\n }\n\n state.bufferedRequest = entry;\n state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n var state = this._writableState;\n\n if (typeof chunk === 'function') {\n cb = chunk;\n chunk = null;\n encoding = null;\n } else if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks\n\n if (state.corked) {\n state.corked = 1;\n this.uncork();\n } // ignore unnecessary end() calls.\n\n\n if (!state.ending) endWritable(this, state, cb);\n return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n});\n\nfunction needFinish(state) {\n return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n stream._final(function (err) {\n state.pendingcb--;\n\n if (err) {\n stream.emit('error', err);\n }\n\n state.prefinished = true;\n stream.emit('prefinish');\n finishMaybe(stream, state);\n });\n}\n\nfunction prefinish(stream, state) {\n if (!state.prefinished && !state.finalCalled) {\n if (typeof stream._final === 'function' && !state.destroyed) {\n state.pendingcb++;\n state.finalCalled = true;\n process.nextTick(callFinal, stream, state);\n } else {\n state.prefinished = true;\n stream.emit('prefinish');\n }\n }\n}\n\nfunction finishMaybe(stream, state) {\n var need = needFinish(state);\n\n if (need) {\n prefinish(stream, state);\n\n if (state.pendingcb === 0) {\n state.finished = true;\n stream.emit('finish');\n }\n }\n\n return need;\n}\n\nfunction endWritable(stream, state, cb) {\n state.ending = true;\n finishMaybe(stream, state);\n\n if (cb) {\n if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n }\n\n state.ended = true;\n stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n var entry = corkReq.entry;\n corkReq.entry = null;\n\n while (entry) {\n var cb = entry.callback;\n state.pendingcb--;\n cb(err);\n entry = entry.next;\n } // reuse the free corkReq.\n\n\n state.corkedRequestsFree.next = corkReq;\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._writableState === undefined) {\n return false;\n }\n\n return this._writableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._writableState) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._writableState.destroyed = value;\n }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n cb(err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a transform stream is a readable/writable stream where you do\n// something with the data. Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored. (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation. For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes. When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up. When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer. When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks. If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk. However,\n// a pathological inflate type of transform can cause excessive buffering\n// here. For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output. In this case, you could write a very small\n// amount of input, and end up with a very large amount of output. In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform. A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n'use strict';\n\nmodule.exports = Transform;\n\nvar _require$codes = require('../errors').codes,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\n\nvar Duplex = require('./_stream_duplex');\n\nrequire('inherits')(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n var ts = this._transformState;\n ts.transforming = false;\n var cb = ts.writecb;\n\n if (cb === null) {\n return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n }\n\n ts.writechunk = null;\n ts.writecb = null;\n if (data != null) // single equals check for both `null` and `undefined`\n this.push(data);\n cb(er);\n var rs = this._readableState;\n rs.reading = false;\n\n if (rs.needReadable || rs.length < rs.highWaterMark) {\n this._read(rs.highWaterMark);\n }\n}\n\nfunction Transform(options) {\n if (!(this instanceof Transform)) return new Transform(options);\n Duplex.call(this, options);\n this._transformState = {\n afterTransform: afterTransform.bind(this),\n needTransform: false,\n transforming: false,\n writecb: null,\n writechunk: null,\n writeencoding: null\n }; // start out asking for a readable event once data is transformed.\n\n this._readableState.needReadable = true; // we have implemented the _read method, and done the other things\n // that Readable wants before the first _read call, so unset the\n // sync guard flag.\n\n this._readableState.sync = false;\n\n if (options) {\n if (typeof options.transform === 'function') this._transform = options.transform;\n if (typeof options.flush === 'function') this._flush = options.flush;\n } // When the writable side finishes, then flush out anything remaining.\n\n\n this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n var _this = this;\n\n if (typeof this._flush === 'function' && !this._readableState.destroyed) {\n this._flush(function (er, data) {\n done(_this, er, data);\n });\n } else {\n done(this, null, null);\n }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n this._transformState.needTransform = false;\n return Duplex.prototype.push.call(this, chunk, encoding);\n}; // This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side. You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk. If you pass\n// an error, then that'll put the hurt on the whole operation. If you\n// never call cb(), then you'll never get another chunk.\n\n\nTransform.prototype._transform = function (chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n var ts = this._transformState;\n ts.writecb = cb;\n ts.writechunk = chunk;\n ts.writeencoding = encoding;\n\n if (!ts.transforming) {\n var rs = this._readableState;\n if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n }\n}; // Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\n\n\nTransform.prototype._read = function (n) {\n var ts = this._transformState;\n\n if (ts.writechunk !== null && !ts.transforming) {\n ts.transforming = true;\n\n this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n } else {\n // mark that we need a transform, so that any data that comes in\n // will get processed, now that we've asked for it.\n ts.needTransform = true;\n }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n Duplex.prototype._destroy.call(this, err, function (err2) {\n cb(err2);\n });\n};\n\nfunction done(stream, er, data) {\n if (er) return stream.emit('error', er);\n if (data != null) // single equals check for both `null` and `undefined`\n stream.push(data); // TODO(BridgeAR): Write a test for these two error cases\n // if there's nothing in the write buffer, then that means\n // that nothing more will ever be provided\n\n if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n return stream.push(null);\n}","// factories to generate all possible parsed by a gerber command\n'use strict'\n\nvar done = function(line) {\n return {type: 'done', line: line || -1}\n}\n\nvar set = function(property, value, line) {\n return {type: 'set', line: line || -1, prop: property, value: value}\n}\n\nvar level = function(level, value, line) {\n return {type: 'level', line: line || -1, level: level, value: value}\n}\n\nvar tool = function(code, tool, line) {\n return {type: 'tool', line: line || -1, code: code, tool: tool}\n}\n\nvar op = function(operation, location, line) {\n return {type: 'op', line: line || -1, op: operation, coord: location}\n}\n\nvar macro = function(name, blocks, line) {\n return {type: 'macro', line: line || -1, name: name, blocks: blocks}\n}\n\nvar commandMap = {\n set: set,\n done: done,\n level: level,\n tool: tool,\n op: op,\n macro: macro,\n}\nmodule.exports = commandMap\n","// cordinate parser function\n// takes in a string with X_____Y_____I_____J_____ and a format object\n// returns an object of {x: number, y: number, etc} for coordinates it finds\n'use strict'\n\n// convert to normalized number\nvar normalize = require('./normalize-coord')\n\nvar RE_TRAILING = /[XY]0\\d+/\nvar RE_LEADING = /[XY]\\d+0(?=\\D|$)/\nvar MATCH = [\n {coord: 'x', test: /X([+-]?[\\d.]+)/},\n {coord: 'y', test: /Y([+-]?[\\d.]+)/},\n {coord: 'i', test: /I([+-]?[\\d.]+)/},\n {coord: 'j', test: /J([+-]?[\\d.]+)/},\n {coord: 'a', test: /A([\\d.]+)/},\n]\n\nvar parse = function(coord, format) {\n if (coord == null) {\n return {}\n }\n\n if (format.zero == null || format.places == null) {\n throw new Error('cannot parse coordinate with format undefined')\n }\n\n // pull out the x, y, i, and j\n var parsed = MATCH.reduce(function(result, matcher) {\n var coordMatch = coord.match(matcher.test)\n\n if (coordMatch) {\n result[matcher.coord] = normalize(coordMatch[1], format)\n }\n\n return result\n }, {})\n\n return parsed\n}\n\nvar detectZero = function(coord) {\n if (RE_LEADING.test(coord)) {\n return 'L'\n }\n\n if (RE_TRAILING.test(coord)) {\n return 'T'\n }\n\n return null\n}\n\nmodule.exports = {parse: parse, detectZero: detectZero}\n","// drill parser drill and route modes\n'use strict'\n\nmodule.exports = {\n DRILL: '5',\n MOVE: '0',\n LINEAR: '1',\n CW_ARC: '2',\n CCW_ARC: '3',\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n'use strict';\n\nmodule.exports = Readable;\n/**/\n\nvar Duplex;\n/**/\n\nReadable.ReadableState = ReadableState;\n/**/\n\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n return emitter.listeners(type).length;\n};\n/**/\n\n/**/\n\n\nvar Stream = require('./internal/streams/stream');\n/**/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/**/\n\n\nvar debugUtil = require('util');\n\nvar debug;\n\nif (debugUtil && debugUtil.debuglog) {\n debug = debugUtil.debuglog('stream');\n} else {\n debug = function debug() {};\n}\n/**/\n\n\nvar BufferList = require('./internal/streams/buffer_list');\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;\n\nvar _require2 = require('../experimentalWarning'),\n emitExperimentalWarning = _require2.emitExperimentalWarning; // Lazy loaded to improve the startup performance.\n\n\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\n\nrequire('inherits')(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n // Sadly this is not cacheable as some libraries bundle their own\n // event emitter implementation with them.\n if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any\n // userland ones. NEVER DO THIS. This is here only because this code needs\n // to continue to work with older versions of Node.js that do not include\n // the prependListener() method. The goal is to eventually remove this hack.\n\n if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream, isDuplex) {\n Duplex = Duplex || require('./_stream_duplex');\n options = options || {}; // Duplex streams are both readable and writable, but share\n // the same options object.\n // However, some cases require setting options to different\n // values for the readable and the writable sides of the duplex stream.\n // These options can be provided separately as readableXXX and writableXXX.\n\n if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to\n // make all the buffer merging and length checks go away\n\n this.objectMode = !!options.objectMode;\n if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer\n // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n\n this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the\n // linked list can remove elements from the beginning faster than\n // array.shift()\n\n this.buffer = new BufferList();\n this.length = 0;\n this.pipes = null;\n this.pipesCount = 0;\n this.flowing = null;\n this.ended = false;\n this.endEmitted = false;\n this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted\n // immediately, or on a later tick. We set this to true at first, because\n // any actions that shouldn't happen until \"later\" should generally also\n // not happen before the first read call.\n\n this.sync = true; // whenever we return null, then we set a flag to say\n // that we're awaiting a 'readable' event emission.\n\n this.needReadable = false;\n this.emittedReadable = false;\n this.readableListening = false;\n this.resumeScheduled = false;\n this.paused = true; // Should close be emitted on destroy. Defaults to true.\n\n this.emitClose = options.emitClose !== false; // has it been destroyed\n\n this.destroyed = false; // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n\n this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s\n\n this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled\n\n this.readingMore = false;\n this.decoder = null;\n this.encoding = null;\n\n if (options.encoding) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n this.decoder = new StringDecoder(options.encoding);\n this.encoding = options.encoding;\n }\n}\n\nfunction Readable(options) {\n Duplex = Duplex || require('./_stream_duplex');\n if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside\n // the ReadableState constructor, at least with V8 6.5\n\n var isDuplex = this instanceof Duplex;\n this._readableState = new ReadableState(options, this, isDuplex); // legacy\n\n this.readable = true;\n\n if (options) {\n if (typeof options.read === 'function') this._read = options.read;\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n }\n\n Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._readableState === undefined) {\n return false;\n }\n\n return this._readableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._readableState) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._readableState.destroyed = value;\n }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\n\nReadable.prototype._destroy = function (err, cb) {\n cb(err);\n}; // Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\n\n\nReadable.prototype.push = function (chunk, encoding) {\n var state = this._readableState;\n var skipChunkCheck;\n\n if (!state.objectMode) {\n if (typeof chunk === 'string') {\n encoding = encoding || state.defaultEncoding;\n\n if (encoding !== state.encoding) {\n chunk = Buffer.from(chunk, encoding);\n encoding = '';\n }\n\n skipChunkCheck = true;\n }\n } else {\n skipChunkCheck = true;\n }\n\n return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n}; // Unshift should *always* be something directly out of read()\n\n\nReadable.prototype.unshift = function (chunk) {\n return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n debug('readableAddChunk', chunk);\n var state = stream._readableState;\n\n if (chunk === null) {\n state.reading = false;\n onEofChunk(stream, state);\n } else {\n var er;\n if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n\n if (er) {\n stream.emit('error', er);\n } else if (state.objectMode || chunk && chunk.length > 0) {\n if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (addToFront) {\n if (state.endEmitted) stream.emit('error', new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n } else if (state.ended) {\n stream.emit('error', new ERR_STREAM_PUSH_AFTER_EOF());\n } else if (state.destroyed) {\n return false;\n } else {\n state.reading = false;\n\n if (state.decoder && !encoding) {\n chunk = state.decoder.write(chunk);\n if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n } else {\n addChunk(stream, state, chunk, false);\n }\n }\n } else if (!addToFront) {\n state.reading = false;\n maybeReadMore(stream, state);\n }\n } // We can push more data if we are below the highWaterMark.\n // Also, if we have no data yet, we can stand some more bytes.\n // This is to work around cases where hwm=0, such as the repl.\n\n\n return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n if (state.flowing && state.length === 0 && !state.sync) {\n state.awaitDrain = 0;\n stream.emit('data', chunk);\n } else {\n // update the buffer info.\n state.length += state.objectMode ? 1 : chunk.length;\n if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n if (state.needReadable) emitReadable(stream);\n }\n\n maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n var er;\n\n if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n }\n\n return er;\n}\n\nReadable.prototype.isPaused = function () {\n return this._readableState.flowing === false;\n}; // backwards compatibility.\n\n\nReadable.prototype.setEncoding = function (enc) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n this._readableState.decoder = new StringDecoder(enc); // if setEncoding(null), decoder.encoding equals utf8\n\n this._readableState.encoding = this._readableState.decoder.encoding;\n return this;\n}; // Don't raise the hwm > 8MB\n\n\nvar MAX_HWM = 0x800000;\n\nfunction computeNewHighWaterMark(n) {\n if (n >= MAX_HWM) {\n n = MAX_HWM;\n } else {\n // Get the next highest power of 2 to prevent increasing hwm excessively in\n // tiny amounts\n n--;\n n |= n >>> 1;\n n |= n >>> 2;\n n |= n >>> 4;\n n |= n >>> 8;\n n |= n >>> 16;\n n++;\n }\n\n return n;\n} // This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\n\nfunction howMuchToRead(n, state) {\n if (n <= 0 || state.length === 0 && state.ended) return 0;\n if (state.objectMode) return 1;\n\n if (n !== n) {\n // Only flow one buffer at a time\n if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n } // If we're asking for more than the current hwm, then raise the hwm.\n\n\n if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n if (n <= state.length) return n; // Don't have enough\n\n if (!state.ended) {\n state.needReadable = true;\n return 0;\n }\n\n return state.length;\n} // you can override either this method, or the async _read(n) below.\n\n\nReadable.prototype.read = function (n) {\n debug('read', n);\n n = parseInt(n, 10);\n var state = this._readableState;\n var nOrig = n;\n if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we\n // already have a bunch of data in the buffer, then just trigger\n // the 'readable' event and move on.\n\n if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n debug('read: emitReadable', state.length, state.ended);\n if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n return null;\n }\n\n n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.\n\n if (n === 0 && state.ended) {\n if (state.length === 0) endReadable(this);\n return null;\n } // All the actual chunk generation logic needs to be\n // *below* the call to _read. The reason is that in certain\n // synthetic stream cases, such as passthrough streams, _read\n // may be a completely synchronous operation which may change\n // the state of the read buffer, providing enough data when\n // before there was *not* enough.\n //\n // So, the steps are:\n // 1. Figure out what the state of things will be after we do\n // a read from the buffer.\n //\n // 2. If that resulting state will trigger a _read, then call _read.\n // Note that this may be asynchronous, or synchronous. Yes, it is\n // deeply ugly to write APIs this way, but that still doesn't mean\n // that the Readable class should behave improperly, as streams are\n // designed to be sync/async agnostic.\n // Take note if the _read call is sync or async (ie, if the read call\n // has returned yet), so that we know whether or not it's safe to emit\n // 'readable' etc.\n //\n // 3. Actually pull the requested chunks out of the buffer and return.\n // if we need a readable event, then we need to do some reading.\n\n\n var doRead = state.needReadable;\n debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some\n\n if (state.length === 0 || state.length - n < state.highWaterMark) {\n doRead = true;\n debug('length less than watermark', doRead);\n } // however, if we've ended, then there's no point, and if we're already\n // reading, then it's unnecessary.\n\n\n if (state.ended || state.reading) {\n doRead = false;\n debug('reading or ended', doRead);\n } else if (doRead) {\n debug('do read');\n state.reading = true;\n state.sync = true; // if the length is currently zero, then we *need* a readable event.\n\n if (state.length === 0) state.needReadable = true; // call internal read method\n\n this._read(state.highWaterMark);\n\n state.sync = false; // If _read pushed data synchronously, then `reading` will be false,\n // and we need to re-evaluate how much data we can return to the user.\n\n if (!state.reading) n = howMuchToRead(nOrig, state);\n }\n\n var ret;\n if (n > 0) ret = fromList(n, state);else ret = null;\n\n if (ret === null) {\n state.needReadable = true;\n n = 0;\n } else {\n state.length -= n;\n state.awaitDrain = 0;\n }\n\n if (state.length === 0) {\n // If we have nothing in the buffer, then we want to know\n // as soon as we *do* get something into the buffer.\n if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.\n\n if (nOrig !== n && state.ended) endReadable(this);\n }\n\n if (ret !== null) this.emit('data', ret);\n return ret;\n};\n\nfunction onEofChunk(stream, state) {\n if (state.ended) return;\n\n if (state.decoder) {\n var chunk = state.decoder.end();\n\n if (chunk && chunk.length) {\n state.buffer.push(chunk);\n state.length += state.objectMode ? 1 : chunk.length;\n }\n }\n\n state.ended = true;\n\n if (state.sync) {\n // if we are sync, wait until next tick to emit the data.\n // Otherwise we risk emitting data in the flow()\n // the readable code triggers during a read() call\n emitReadable(stream);\n } else {\n // emit 'readable' now to make sure it gets picked up.\n state.needReadable = false;\n\n if (!state.emittedReadable) {\n state.emittedReadable = true;\n emitReadable_(stream);\n }\n }\n} // Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow. This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\n\n\nfunction emitReadable(stream) {\n var state = stream._readableState;\n state.needReadable = false;\n\n if (!state.emittedReadable) {\n debug('emitReadable', state.flowing);\n state.emittedReadable = true;\n process.nextTick(emitReadable_, stream);\n }\n}\n\nfunction emitReadable_(stream) {\n var state = stream._readableState;\n debug('emitReadable_', state.destroyed, state.length, state.ended);\n\n if (!state.destroyed && (state.length || state.ended)) {\n stream.emit('readable');\n } // The stream needs another readable event if\n // 1. It is not flowing, as the flow mechanism will take\n // care of it.\n // 2. It is not ended.\n // 3. It is below the highWaterMark, so we can schedule\n // another readable later.\n\n\n state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n flow(stream);\n} // at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data. that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\n\n\nfunction maybeReadMore(stream, state) {\n if (!state.readingMore) {\n state.readingMore = true;\n process.nextTick(maybeReadMore_, stream, state);\n }\n}\n\nfunction maybeReadMore_(stream, state) {\n // Attempt to read more data if we should.\n //\n // The conditions for reading more data are (one of):\n // - Not enough data buffered (state.length < state.highWaterMark). The loop\n // is responsible for filling the buffer with enough data if such data\n // is available. If highWaterMark is 0 and we are not in the flowing mode\n // we should _not_ attempt to buffer any extra data. We'll get more data\n // when the stream consumer calls read() instead.\n // - No data in the buffer, and the stream is in flowing mode. In this mode\n // the loop below is responsible for ensuring read() is called. Failing to\n // call read here would abort the flow and there's no other mechanism for\n // continuing the flow if the stream consumer has just subscribed to the\n // 'data' event.\n //\n // In addition to the above conditions to keep reading data, the following\n // conditions prevent the data from being read:\n // - The stream has ended (state.ended).\n // - There is already a pending 'read' operation (state.reading). This is a\n // case where the the stream has called the implementation defined _read()\n // method, but they are processing the call asynchronously and have _not_\n // called push() with new data. In this case we skip performing more\n // read()s. The execution ends in this method again after the _read() ends\n // up calling push() with more data.\n while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n var len = state.length;\n debug('maybeReadMore read 0');\n stream.read(0);\n if (len === state.length) // didn't get any data, stop spinning.\n break;\n }\n\n state.readingMore = false;\n} // abstract method. to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\n\n\nReadable.prototype._read = function (n) {\n this.emit('error', new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n var src = this;\n var state = this._readableState;\n\n switch (state.pipesCount) {\n case 0:\n state.pipes = dest;\n break;\n\n case 1:\n state.pipes = [state.pipes, dest];\n break;\n\n default:\n state.pipes.push(dest);\n break;\n }\n\n state.pipesCount += 1;\n debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n var endFn = doEnd ? onend : unpipe;\n if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\n dest.on('unpipe', onunpipe);\n\n function onunpipe(readable, unpipeInfo) {\n debug('onunpipe');\n\n if (readable === src) {\n if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n unpipeInfo.hasUnpiped = true;\n cleanup();\n }\n }\n }\n\n function onend() {\n debug('onend');\n dest.end();\n } // when the dest drains, it reduces the awaitDrain counter\n // on the source. This would be more elegant with a .once()\n // handler in flow(), but adding and removing repeatedly is\n // too slow.\n\n\n var ondrain = pipeOnDrain(src);\n dest.on('drain', ondrain);\n var cleanedUp = false;\n\n function cleanup() {\n debug('cleanup'); // cleanup event handlers once the pipe is broken\n\n dest.removeListener('close', onclose);\n dest.removeListener('finish', onfinish);\n dest.removeListener('drain', ondrain);\n dest.removeListener('error', onerror);\n dest.removeListener('unpipe', onunpipe);\n src.removeListener('end', onend);\n src.removeListener('end', unpipe);\n src.removeListener('data', ondata);\n cleanedUp = true; // if the reader is waiting for a drain event from this\n // specific writer, then it would cause it to never start\n // flowing again.\n // So, if this is awaiting a drain, then we just call it now.\n // If we don't know, then assume that we are waiting for one.\n\n if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n }\n\n src.on('data', ondata);\n\n function ondata(chunk) {\n debug('ondata');\n var ret = dest.write(chunk);\n debug('dest.write', ret);\n\n if (ret === false) {\n // If the user unpiped during `dest.write()`, it is possible\n // to get stuck in a permanently paused state if that write\n // also returned false.\n // => Check whether `dest` is still a piping destination.\n if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n debug('false write response, pause', state.awaitDrain);\n state.awaitDrain++;\n }\n\n src.pause();\n }\n } // if the dest has an error, then stop piping into it.\n // however, don't suppress the throwing behavior for this.\n\n\n function onerror(er) {\n debug('onerror', er);\n unpipe();\n dest.removeListener('error', onerror);\n if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n } // Make sure our error handler is attached before userland ones.\n\n\n prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.\n\n function onclose() {\n dest.removeListener('finish', onfinish);\n unpipe();\n }\n\n dest.once('close', onclose);\n\n function onfinish() {\n debug('onfinish');\n dest.removeListener('close', onclose);\n unpipe();\n }\n\n dest.once('finish', onfinish);\n\n function unpipe() {\n debug('unpipe');\n src.unpipe(dest);\n } // tell the dest that it's being piped to\n\n\n dest.emit('pipe', src); // start the flow if it hasn't been started already.\n\n if (!state.flowing) {\n debug('pipe resume');\n src.resume();\n }\n\n return dest;\n};\n\nfunction pipeOnDrain(src) {\n return function pipeOnDrainFunctionResult() {\n var state = src._readableState;\n debug('pipeOnDrain', state.awaitDrain);\n if (state.awaitDrain) state.awaitDrain--;\n\n if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n state.flowing = true;\n flow(src);\n }\n };\n}\n\nReadable.prototype.unpipe = function (dest) {\n var state = this._readableState;\n var unpipeInfo = {\n hasUnpiped: false\n }; // if we're not piping anywhere, then do nothing.\n\n if (state.pipesCount === 0) return this; // just one destination. most common case.\n\n if (state.pipesCount === 1) {\n // passed in one, but it's not the right one.\n if (dest && dest !== state.pipes) return this;\n if (!dest) dest = state.pipes; // got a match.\n\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n if (dest) dest.emit('unpipe', this, unpipeInfo);\n return this;\n } // slow case. multiple pipe destinations.\n\n\n if (!dest) {\n // remove all.\n var dests = state.pipes;\n var len = state.pipesCount;\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n\n for (var i = 0; i < len; i++) {\n dests[i].emit('unpipe', this, {\n hasUnpiped: false\n });\n }\n\n return this;\n } // try to find the right one.\n\n\n var index = indexOf(state.pipes, dest);\n if (index === -1) return this;\n state.pipes.splice(index, 1);\n state.pipesCount -= 1;\n if (state.pipesCount === 1) state.pipes = state.pipes[0];\n dest.emit('unpipe', this, unpipeInfo);\n return this;\n}; // set up data events if they are asked for\n// Ensure readable listeners eventually get something\n\n\nReadable.prototype.on = function (ev, fn) {\n var res = Stream.prototype.on.call(this, ev, fn);\n var state = this._readableState;\n\n if (ev === 'data') {\n // update readableListening so that resume() may be a no-op\n // a few lines down. This is needed to support once('readable').\n state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused\n\n if (state.flowing !== false) this.resume();\n } else if (ev === 'readable') {\n if (!state.endEmitted && !state.readableListening) {\n state.readableListening = state.needReadable = true;\n state.flowing = false;\n state.emittedReadable = false;\n debug('on readable', state.length, state.reading);\n\n if (state.length) {\n emitReadable(this);\n } else if (!state.reading) {\n process.nextTick(nReadingNextTick, this);\n }\n }\n }\n\n return res;\n};\n\nReadable.prototype.addListener = Readable.prototype.on;\n\nReadable.prototype.removeListener = function (ev, fn) {\n var res = Stream.prototype.removeListener.call(this, ev, fn);\n\n if (ev === 'readable') {\n // We need to check if there is someone still listening to\n // readable and reset the state. However this needs to happen\n // after readable has been emitted but before I/O (nextTick) to\n // support once('readable', fn) cycles. This means that calling\n // resume within the same tick will have no\n // effect.\n process.nextTick(updateReadableListening, this);\n }\n\n return res;\n};\n\nReadable.prototype.removeAllListeners = function (ev) {\n var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n\n if (ev === 'readable' || ev === undefined) {\n // We need to check if there is someone still listening to\n // readable and reset the state. However this needs to happen\n // after readable has been emitted but before I/O (nextTick) to\n // support once('readable', fn) cycles. This means that calling\n // resume within the same tick will have no\n // effect.\n process.nextTick(updateReadableListening, this);\n }\n\n return res;\n};\n\nfunction updateReadableListening(self) {\n var state = self._readableState;\n state.readableListening = self.listenerCount('readable') > 0;\n\n if (state.resumeScheduled && !state.paused) {\n // flowing needs to be set to true now, otherwise\n // the upcoming resume will not flow.\n state.flowing = true; // crude way to check if we should resume\n } else if (self.listenerCount('data') > 0) {\n self.resume();\n }\n}\n\nfunction nReadingNextTick(self) {\n debug('readable nexttick read 0');\n self.read(0);\n} // pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\n\n\nReadable.prototype.resume = function () {\n var state = this._readableState;\n\n if (!state.flowing) {\n debug('resume'); // we flow only if there is no one listening\n // for readable, but we still have to call\n // resume()\n\n state.flowing = !state.readableListening;\n resume(this, state);\n }\n\n state.paused = false;\n return this;\n};\n\nfunction resume(stream, state) {\n if (!state.resumeScheduled) {\n state.resumeScheduled = true;\n process.nextTick(resume_, stream, state);\n }\n}\n\nfunction resume_(stream, state) {\n debug('resume', state.reading);\n\n if (!state.reading) {\n stream.read(0);\n }\n\n state.resumeScheduled = false;\n stream.emit('resume');\n flow(stream);\n if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n debug('call pause flowing=%j', this._readableState.flowing);\n\n if (this._readableState.flowing !== false) {\n debug('pause');\n this._readableState.flowing = false;\n this.emit('pause');\n }\n\n this._readableState.paused = true;\n return this;\n};\n\nfunction flow(stream) {\n var state = stream._readableState;\n debug('flow', state.flowing);\n\n while (state.flowing && stream.read() !== null) {\n ;\n }\n} // wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\n\n\nReadable.prototype.wrap = function (stream) {\n var _this = this;\n\n var state = this._readableState;\n var paused = false;\n stream.on('end', function () {\n debug('wrapped end');\n\n if (state.decoder && !state.ended) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length) _this.push(chunk);\n }\n\n _this.push(null);\n });\n stream.on('data', function (chunk) {\n debug('wrapped data');\n if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode\n\n if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n var ret = _this.push(chunk);\n\n if (!ret) {\n paused = true;\n stream.pause();\n }\n }); // proxy all the other methods.\n // important when wrapping filters and duplexes.\n\n for (var i in stream) {\n if (this[i] === undefined && typeof stream[i] === 'function') {\n this[i] = function methodWrap(method) {\n return function methodWrapReturnFunction() {\n return stream[method].apply(stream, arguments);\n };\n }(i);\n }\n } // proxy certain important events.\n\n\n for (var n = 0; n < kProxyEvents.length; n++) {\n stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n } // when we try to consume some more bytes, simply unpause the\n // underlying stream.\n\n\n this._read = function (n) {\n debug('wrapped _read', n);\n\n if (paused) {\n paused = false;\n stream.resume();\n }\n };\n\n return this;\n};\n\nif (typeof Symbol === 'function') {\n Readable.prototype[Symbol.asyncIterator] = function () {\n emitExperimentalWarning('Readable[Symbol.asyncIterator]');\n\n if (createReadableStreamAsyncIterator === undefined) {\n createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n }\n\n return createReadableStreamAsyncIterator(this);\n };\n}\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.highWaterMark;\n }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState && this._readableState.buffer;\n }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.flowing;\n },\n set: function set(state) {\n if (this._readableState) {\n this._readableState.flowing = state;\n }\n }\n}); // exposed for testing purposes only.\n\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.length;\n }\n}); // Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\nfunction fromList(n, state) {\n // nothing buffered\n if (state.length === 0) return null;\n var ret;\n if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n // read it all, truncate the list\n if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);\n state.buffer.clear();\n } else {\n // read part of list\n ret = state.buffer.consume(n, state.decoder);\n }\n return ret;\n}\n\nfunction endReadable(stream) {\n var state = stream._readableState;\n debug('endReadable', state.endEmitted);\n\n if (!state.endEmitted) {\n state.ended = true;\n process.nextTick(endReadableNT, state, stream);\n }\n}\n\nfunction endReadableNT(state, stream) {\n debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.\n\n if (!state.endEmitted && state.length === 0) {\n state.endEmitted = true;\n stream.readable = false;\n stream.emit('end');\n }\n}\n\nfunction indexOf(xs, x) {\n for (var i = 0, l = xs.length; i < l; i++) {\n if (xs[i] === x) return i;\n }\n\n return -1;\n}","module.exports = require('events').EventEmitter;\n","'use strict'; // undocumented cb() API, needed for core, not for public API\n\nfunction destroy(err, cb) {\n var _this = this;\n\n var readableDestroyed = this._readableState && this._readableState.destroyed;\n var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n if (readableDestroyed || writableDestroyed) {\n if (cb) {\n cb(err);\n } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n process.nextTick(emitErrorNT, this, err);\n }\n\n return this;\n } // we set destroyed to true before firing error callbacks in order\n // to make it re-entrance safe in case destroy() is called within callbacks\n\n\n if (this._readableState) {\n this._readableState.destroyed = true;\n } // if this is a duplex stream mark the writable part as destroyed as well\n\n\n if (this._writableState) {\n this._writableState.destroyed = true;\n }\n\n this._destroy(err || null, function (err) {\n if (!cb && err) {\n process.nextTick(emitErrorAndCloseNT, _this, err);\n\n if (_this._writableState) {\n _this._writableState.errorEmitted = true;\n }\n } else if (cb) {\n process.nextTick(emitCloseNT, _this);\n cb(err);\n } else {\n process.nextTick(emitCloseNT, _this);\n }\n });\n\n return this;\n}\n\nfunction emitErrorAndCloseNT(self, err) {\n emitErrorNT(self, err);\n emitCloseNT(self);\n}\n\nfunction emitCloseNT(self) {\n if (self._writableState && !self._writableState.emitClose) return;\n if (self._readableState && !self._readableState.emitClose) return;\n self.emit('close');\n}\n\nfunction undestroy() {\n if (this._readableState) {\n this._readableState.destroyed = false;\n this._readableState.reading = false;\n this._readableState.ended = false;\n this._readableState.endEmitted = false;\n }\n\n if (this._writableState) {\n this._writableState.destroyed = false;\n this._writableState.ended = false;\n this._writableState.ending = false;\n this._writableState.finalCalled = false;\n this._writableState.prefinished = false;\n this._writableState.finished = false;\n this._writableState.errorEmitted = false;\n }\n}\n\nfunction emitErrorNT(self, err) {\n self.emit('error', err);\n}\n\nmodule.exports = {\n destroy: destroy,\n undestroy: undestroy\n};","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\n\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\n\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n\n if (hwm != null) {\n if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n var name = isDuplex ? duplexKey : 'highWaterMark';\n throw new ERR_INVALID_OPT_VALUE(name, hwm);\n }\n\n return Math.floor(hwm);\n } // Default value\n\n\n return state.objectMode ? 16 : 16 * 1024;\n}\n\nmodule.exports = {\n getHighWaterMark: getHighWaterMark\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n'use strict';\n\nmodule.exports = Writable;\n/* */\n\nfunction WriteReq(chunk, encoding, cb) {\n this.chunk = chunk;\n this.encoding = encoding;\n this.callback = cb;\n this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n var _this = this;\n\n this.next = null;\n this.entry = null;\n\n this.finish = function () {\n onCorkedFinish(_this, state);\n };\n}\n/* */\n\n/**/\n\n\nvar Duplex;\n/**/\n\nWritable.WritableState = WritableState;\n/**/\n\nvar internalUtil = {\n deprecate: require('util-deprecate')\n};\n/**/\n\n/**/\n\nvar Stream = require('./internal/streams/stream');\n/**/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n Duplex = Duplex || require('./_stream_duplex');\n options = options || {}; // Duplex streams are both readable and writable, but share\n // the same options object.\n // However, some cases require setting options to different\n // values for the readable and the writable sides of the duplex stream,\n // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n\n if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n // contains buffers or objects.\n\n this.objectMode = !!options.objectMode;\n if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false\n // Note: 0 is a valid value, means that we always return false if\n // the entire buffer is not flushed immediately on write()\n\n this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n this.finalCalled = false; // drain event flag.\n\n this.needDrain = false; // at the start of calling end()\n\n this.ending = false; // when end() has been called, and returned\n\n this.ended = false; // when 'finish' is emitted\n\n this.finished = false; // has it been destroyed\n\n this.destroyed = false; // should we decode strings into buffers before passing to _write?\n // this is here so that some node-core streams can optimize string\n // handling at a lower level.\n\n var noDecode = options.decodeStrings === false;\n this.decodeStrings = !noDecode; // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n\n this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement\n // of how much we're waiting to get pushed to some underlying\n // socket or file.\n\n this.length = 0; // a flag to see when we're in the middle of a write.\n\n this.writing = false; // when true all writes will be buffered until .uncork() call\n\n this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,\n // or on a later tick. We set this to true at first, because any\n // actions that shouldn't happen until \"later\" should generally also\n // not happen before the first write call.\n\n this.sync = true; // a flag to know if we're processing previously buffered items, which\n // may call the _write() callback in the same tick, so that we don't\n // end up in an overlapped onwrite situation.\n\n this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n this.onwrite = function (er) {\n onwrite(stream, er);\n }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n this.writecb = null; // the amount that is being written when _write is called.\n\n this.writelen = 0;\n this.bufferedRequest = null;\n this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n // this must be 0 before 'finish' can be emitted\n\n this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n // This is relevant for synchronous Transform streams\n\n this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n this.emitClose = options.emitClose !== false; // count buffered requests\n\n this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n // one allocated and free to use, and we maintain at most two\n\n this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n var current = this.bufferedRequest;\n var out = [];\n\n while (current) {\n out.push(current);\n current = current.next;\n }\n\n return out;\n};\n\n(function () {\n try {\n Object.defineProperty(WritableState.prototype, 'buffer', {\n get: internalUtil.deprecate(function writableStateBufferGetter() {\n return this.getBuffer();\n }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n });\n } catch (_) {}\n})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n realHasInstance = Function.prototype[Symbol.hasInstance];\n Object.defineProperty(Writable, Symbol.hasInstance, {\n value: function value(object) {\n if (realHasInstance.call(this, object)) return true;\n if (this !== Writable) return false;\n return object && object._writableState instanceof WritableState;\n }\n });\n} else {\n realHasInstance = function realHasInstance(object) {\n return object instanceof this;\n };\n}\n\nfunction Writable(options) {\n Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.\n // `realHasInstance` is necessary because using plain `instanceof`\n // would return false, as no `_writableState` property is attached.\n // Trying to use the custom `instanceof` for Writable here will also break the\n // Node.js LazyTransform implementation, which has a non-trivial getter for\n // `_writableState` that would lead to infinite recursion.\n // Checking for a Stream.Duplex instance is faster here instead of inside\n // the WritableState constructor, at least with V8 6.5\n\n var isDuplex = this instanceof Duplex;\n if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n this._writableState = new WritableState(options, this, isDuplex); // legacy.\n\n this.writable = true;\n\n if (options) {\n if (typeof options.write === 'function') this._write = options.write;\n if (typeof options.writev === 'function') this._writev = options.writev;\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n if (typeof options.final === 'function') this._final = options.final;\n }\n\n Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n this.emit('error', new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n stream.emit('error', er);\n process.nextTick(cb, er);\n} // Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n var er;\n\n if (chunk === null) {\n er = new ERR_STREAM_NULL_VALUES();\n } else if (typeof chunk !== 'string' && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n }\n\n if (er) {\n stream.emit('error', er);\n process.nextTick(cb, er);\n return false;\n }\n\n return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n var state = this._writableState;\n var ret = false;\n\n var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n if (isBuf && !Buffer.isBuffer(chunk)) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n if (typeof cb !== 'function') cb = nop;\n if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n state.pendingcb++;\n ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n }\n return ret;\n};\n\nWritable.prototype.cork = function () {\n this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n var state = this._writableState;\n\n if (state.corked) {\n state.corked--;\n if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n // node::ParseEncoding() requires lower case.\n if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n this._writableState.defaultEncoding = encoding;\n return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n});\n\nfunction decodeChunk(state, chunk, encoding) {\n if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n chunk = Buffer.from(chunk, encoding);\n }\n\n return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n}); // if we're already writing something, then just put this\n// in the queue, and wait our turn. Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n if (!isBuf) {\n var newChunk = decodeChunk(state, chunk, encoding);\n\n if (chunk !== newChunk) {\n isBuf = true;\n encoding = 'buffer';\n chunk = newChunk;\n }\n }\n\n var len = state.objectMode ? 1 : chunk.length;\n state.length += len;\n var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\n if (!ret) state.needDrain = true;\n\n if (state.writing || state.corked) {\n var last = state.lastBufferedRequest;\n state.lastBufferedRequest = {\n chunk: chunk,\n encoding: encoding,\n isBuf: isBuf,\n callback: cb,\n next: null\n };\n\n if (last) {\n last.next = state.lastBufferedRequest;\n } else {\n state.bufferedRequest = state.lastBufferedRequest;\n }\n\n state.bufferedRequestCount += 1;\n } else {\n doWrite(stream, state, false, len, chunk, encoding, cb);\n }\n\n return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n state.writelen = len;\n state.writecb = cb;\n state.writing = true;\n state.sync = true;\n if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n --state.pendingcb;\n\n if (sync) {\n // defer the callback if we are being called synchronously\n // to avoid piling up things on the stack\n process.nextTick(cb, er); // this can emit finish, and it will always happen\n // after error\n\n process.nextTick(finishMaybe, stream, state);\n stream._writableState.errorEmitted = true;\n stream.emit('error', er);\n } else {\n // the caller expect this to happen before if\n // it is async\n cb(er);\n stream._writableState.errorEmitted = true;\n stream.emit('error', er); // this can emit finish, but finish must\n // always follow error\n\n finishMaybe(stream, state);\n }\n}\n\nfunction onwriteStateUpdate(state) {\n state.writing = false;\n state.writecb = null;\n state.length -= state.writelen;\n state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n var state = stream._writableState;\n var sync = state.sync;\n var cb = state.writecb;\n if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n onwriteStateUpdate(state);\n if (er) onwriteError(stream, state, sync, er, cb);else {\n // Check if we're actually ready to finish, but don't emit yet\n var finished = needFinish(state) || stream.destroyed;\n\n if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n clearBuffer(stream, state);\n }\n\n if (sync) {\n process.nextTick(afterWrite, stream, state, finished, cb);\n } else {\n afterWrite(stream, state, finished, cb);\n }\n }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n if (!finished) onwriteDrain(stream, state);\n state.pendingcb--;\n cb();\n finishMaybe(stream, state);\n} // Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\n\n\nfunction onwriteDrain(stream, state) {\n if (state.length === 0 && state.needDrain) {\n state.needDrain = false;\n stream.emit('drain');\n }\n} // if there's something in the buffer waiting, then process it\n\n\nfunction clearBuffer(stream, state) {\n state.bufferProcessing = true;\n var entry = state.bufferedRequest;\n\n if (stream._writev && entry && entry.next) {\n // Fast case, write everything using _writev()\n var l = state.bufferedRequestCount;\n var buffer = new Array(l);\n var holder = state.corkedRequestsFree;\n holder.entry = entry;\n var count = 0;\n var allBuffers = true;\n\n while (entry) {\n buffer[count] = entry;\n if (!entry.isBuf) allBuffers = false;\n entry = entry.next;\n count += 1;\n }\n\n buffer.allBuffers = allBuffers;\n doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n // as the hot path ends with doWrite\n\n state.pendingcb++;\n state.lastBufferedRequest = null;\n\n if (holder.next) {\n state.corkedRequestsFree = holder.next;\n holder.next = null;\n } else {\n state.corkedRequestsFree = new CorkedRequest(state);\n }\n\n state.bufferedRequestCount = 0;\n } else {\n // Slow case, write chunks one-by-one\n while (entry) {\n var chunk = entry.chunk;\n var encoding = entry.encoding;\n var cb = entry.callback;\n var len = state.objectMode ? 1 : chunk.length;\n doWrite(stream, state, false, len, chunk, encoding, cb);\n entry = entry.next;\n state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then\n // it means that we need to wait until it does.\n // also, that means that the chunk and cb are currently\n // being processed, so move the buffer counter past them.\n\n if (state.writing) {\n break;\n }\n }\n\n if (entry === null) state.lastBufferedRequest = null;\n }\n\n state.bufferedRequest = entry;\n state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n var state = this._writableState;\n\n if (typeof chunk === 'function') {\n cb = chunk;\n chunk = null;\n encoding = null;\n } else if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks\n\n if (state.corked) {\n state.corked = 1;\n this.uncork();\n } // ignore unnecessary end() calls.\n\n\n if (!state.ending) endWritable(this, state, cb);\n return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n});\n\nfunction needFinish(state) {\n return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n stream._final(function (err) {\n state.pendingcb--;\n\n if (err) {\n stream.emit('error', err);\n }\n\n state.prefinished = true;\n stream.emit('prefinish');\n finishMaybe(stream, state);\n });\n}\n\nfunction prefinish(stream, state) {\n if (!state.prefinished && !state.finalCalled) {\n if (typeof stream._final === 'function' && !state.destroyed) {\n state.pendingcb++;\n state.finalCalled = true;\n process.nextTick(callFinal, stream, state);\n } else {\n state.prefinished = true;\n stream.emit('prefinish');\n }\n }\n}\n\nfunction finishMaybe(stream, state) {\n var need = needFinish(state);\n\n if (need) {\n prefinish(stream, state);\n\n if (state.pendingcb === 0) {\n state.finished = true;\n stream.emit('finish');\n }\n }\n\n return need;\n}\n\nfunction endWritable(stream, state, cb) {\n state.ending = true;\n finishMaybe(stream, state);\n\n if (cb) {\n if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n }\n\n state.ended = true;\n stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n var entry = corkReq.entry;\n corkReq.entry = null;\n\n while (entry) {\n var cb = entry.callback;\n state.pendingcb--;\n cb(err);\n entry = entry.next;\n } // reuse the free corkReq.\n\n\n state.corkedRequestsFree.next = corkReq;\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._writableState === undefined) {\n return false;\n }\n\n return this._writableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._writableState) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._writableState.destroyed = value;\n }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n cb(err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a transform stream is a readable/writable stream where you do\n// something with the data. Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored. (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation. For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes. When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up. When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer. When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks. If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk. However,\n// a pathological inflate type of transform can cause excessive buffering\n// here. For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output. In this case, you could write a very small\n// amount of input, and end up with a very large amount of output. In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform. A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n'use strict';\n\nmodule.exports = Transform;\n\nvar _require$codes = require('../errors').codes,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\n\nvar Duplex = require('./_stream_duplex');\n\nrequire('inherits')(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n var ts = this._transformState;\n ts.transforming = false;\n var cb = ts.writecb;\n\n if (cb === null) {\n return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n }\n\n ts.writechunk = null;\n ts.writecb = null;\n if (data != null) // single equals check for both `null` and `undefined`\n this.push(data);\n cb(er);\n var rs = this._readableState;\n rs.reading = false;\n\n if (rs.needReadable || rs.length < rs.highWaterMark) {\n this._read(rs.highWaterMark);\n }\n}\n\nfunction Transform(options) {\n if (!(this instanceof Transform)) return new Transform(options);\n Duplex.call(this, options);\n this._transformState = {\n afterTransform: afterTransform.bind(this),\n needTransform: false,\n transforming: false,\n writecb: null,\n writechunk: null,\n writeencoding: null\n }; // start out asking for a readable event once data is transformed.\n\n this._readableState.needReadable = true; // we have implemented the _read method, and done the other things\n // that Readable wants before the first _read call, so unset the\n // sync guard flag.\n\n this._readableState.sync = false;\n\n if (options) {\n if (typeof options.transform === 'function') this._transform = options.transform;\n if (typeof options.flush === 'function') this._flush = options.flush;\n } // When the writable side finishes, then flush out anything remaining.\n\n\n this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n var _this = this;\n\n if (typeof this._flush === 'function' && !this._readableState.destroyed) {\n this._flush(function (er, data) {\n done(_this, er, data);\n });\n } else {\n done(this, null, null);\n }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n this._transformState.needTransform = false;\n return Duplex.prototype.push.call(this, chunk, encoding);\n}; // This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side. You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk. If you pass\n// an error, then that'll put the hurt on the whole operation. If you\n// never call cb(), then you'll never get another chunk.\n\n\nTransform.prototype._transform = function (chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n var ts = this._transformState;\n ts.writecb = cb;\n ts.writechunk = chunk;\n ts.writeencoding = encoding;\n\n if (!ts.transforming) {\n var rs = this._readableState;\n if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n }\n}; // Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\n\n\nTransform.prototype._read = function (n) {\n var ts = this._transformState;\n\n if (ts.writechunk !== null && !ts.transforming) {\n ts.transforming = true;\n\n this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n } else {\n // mark that we need a transform, so that any data that comes in\n // will get processed, now that we've asked for it.\n ts.needTransform = true;\n }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n Duplex.prototype._destroy.call(this, err, function (err2) {\n cb(err2);\n });\n};\n\nfunction done(stream, er, data) {\n if (er) return stream.emit('error', er);\n if (data != null) // single equals check for both `null` and `undefined`\n stream.push(data); // TODO(BridgeAR): Write a test for these two error cases\n // if there's nothing in the write buffer, then that means\n // that nothing more will ever be provided\n\n if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n return stream.push(null);\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n'use strict';\n\nmodule.exports = Readable;\n/**/\n\nvar Duplex;\n/**/\n\nReadable.ReadableState = ReadableState;\n/**/\n\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n return emitter.listeners(type).length;\n};\n/**/\n\n/**/\n\n\nvar Stream = require('./internal/streams/stream');\n/**/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/**/\n\n\nvar debugUtil = require('util');\n\nvar debug;\n\nif (debugUtil && debugUtil.debuglog) {\n debug = debugUtil.debuglog('stream');\n} else {\n debug = function debug() {};\n}\n/**/\n\n\nvar BufferList = require('./internal/streams/buffer_list');\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;\n\nvar _require2 = require('../experimentalWarning'),\n emitExperimentalWarning = _require2.emitExperimentalWarning; // Lazy loaded to improve the startup performance.\n\n\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\n\nrequire('inherits')(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n // Sadly this is not cacheable as some libraries bundle their own\n // event emitter implementation with them.\n if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any\n // userland ones. NEVER DO THIS. This is here only because this code needs\n // to continue to work with older versions of Node.js that do not include\n // the prependListener() method. The goal is to eventually remove this hack.\n\n if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream, isDuplex) {\n Duplex = Duplex || require('./_stream_duplex');\n options = options || {}; // Duplex streams are both readable and writable, but share\n // the same options object.\n // However, some cases require setting options to different\n // values for the readable and the writable sides of the duplex stream.\n // These options can be provided separately as readableXXX and writableXXX.\n\n if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to\n // make all the buffer merging and length checks go away\n\n this.objectMode = !!options.objectMode;\n if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer\n // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n\n this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the\n // linked list can remove elements from the beginning faster than\n // array.shift()\n\n this.buffer = new BufferList();\n this.length = 0;\n this.pipes = null;\n this.pipesCount = 0;\n this.flowing = null;\n this.ended = false;\n this.endEmitted = false;\n this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted\n // immediately, or on a later tick. We set this to true at first, because\n // any actions that shouldn't happen until \"later\" should generally also\n // not happen before the first read call.\n\n this.sync = true; // whenever we return null, then we set a flag to say\n // that we're awaiting a 'readable' event emission.\n\n this.needReadable = false;\n this.emittedReadable = false;\n this.readableListening = false;\n this.resumeScheduled = false;\n this.paused = true; // Should close be emitted on destroy. Defaults to true.\n\n this.emitClose = options.emitClose !== false; // has it been destroyed\n\n this.destroyed = false; // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n\n this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s\n\n this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled\n\n this.readingMore = false;\n this.decoder = null;\n this.encoding = null;\n\n if (options.encoding) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n this.decoder = new StringDecoder(options.encoding);\n this.encoding = options.encoding;\n }\n}\n\nfunction Readable(options) {\n Duplex = Duplex || require('./_stream_duplex');\n if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside\n // the ReadableState constructor, at least with V8 6.5\n\n var isDuplex = this instanceof Duplex;\n this._readableState = new ReadableState(options, this, isDuplex); // legacy\n\n this.readable = true;\n\n if (options) {\n if (typeof options.read === 'function') this._read = options.read;\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n }\n\n Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._readableState === undefined) {\n return false;\n }\n\n return this._readableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._readableState) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._readableState.destroyed = value;\n }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\n\nReadable.prototype._destroy = function (err, cb) {\n cb(err);\n}; // Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\n\n\nReadable.prototype.push = function (chunk, encoding) {\n var state = this._readableState;\n var skipChunkCheck;\n\n if (!state.objectMode) {\n if (typeof chunk === 'string') {\n encoding = encoding || state.defaultEncoding;\n\n if (encoding !== state.encoding) {\n chunk = Buffer.from(chunk, encoding);\n encoding = '';\n }\n\n skipChunkCheck = true;\n }\n } else {\n skipChunkCheck = true;\n }\n\n return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n}; // Unshift should *always* be something directly out of read()\n\n\nReadable.prototype.unshift = function (chunk) {\n return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n debug('readableAddChunk', chunk);\n var state = stream._readableState;\n\n if (chunk === null) {\n state.reading = false;\n onEofChunk(stream, state);\n } else {\n var er;\n if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n\n if (er) {\n stream.emit('error', er);\n } else if (state.objectMode || chunk && chunk.length > 0) {\n if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (addToFront) {\n if (state.endEmitted) stream.emit('error', new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n } else if (state.ended) {\n stream.emit('error', new ERR_STREAM_PUSH_AFTER_EOF());\n } else if (state.destroyed) {\n return false;\n } else {\n state.reading = false;\n\n if (state.decoder && !encoding) {\n chunk = state.decoder.write(chunk);\n if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n } else {\n addChunk(stream, state, chunk, false);\n }\n }\n } else if (!addToFront) {\n state.reading = false;\n maybeReadMore(stream, state);\n }\n } // We can push more data if we are below the highWaterMark.\n // Also, if we have no data yet, we can stand some more bytes.\n // This is to work around cases where hwm=0, such as the repl.\n\n\n return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n if (state.flowing && state.length === 0 && !state.sync) {\n state.awaitDrain = 0;\n stream.emit('data', chunk);\n } else {\n // update the buffer info.\n state.length += state.objectMode ? 1 : chunk.length;\n if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n if (state.needReadable) emitReadable(stream);\n }\n\n maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n var er;\n\n if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n }\n\n return er;\n}\n\nReadable.prototype.isPaused = function () {\n return this._readableState.flowing === false;\n}; // backwards compatibility.\n\n\nReadable.prototype.setEncoding = function (enc) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n this._readableState.decoder = new StringDecoder(enc); // if setEncoding(null), decoder.encoding equals utf8\n\n this._readableState.encoding = this._readableState.decoder.encoding;\n return this;\n}; // Don't raise the hwm > 8MB\n\n\nvar MAX_HWM = 0x800000;\n\nfunction computeNewHighWaterMark(n) {\n if (n >= MAX_HWM) {\n n = MAX_HWM;\n } else {\n // Get the next highest power of 2 to prevent increasing hwm excessively in\n // tiny amounts\n n--;\n n |= n >>> 1;\n n |= n >>> 2;\n n |= n >>> 4;\n n |= n >>> 8;\n n |= n >>> 16;\n n++;\n }\n\n return n;\n} // This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\n\nfunction howMuchToRead(n, state) {\n if (n <= 0 || state.length === 0 && state.ended) return 0;\n if (state.objectMode) return 1;\n\n if (n !== n) {\n // Only flow one buffer at a time\n if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n } // If we're asking for more than the current hwm, then raise the hwm.\n\n\n if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n if (n <= state.length) return n; // Don't have enough\n\n if (!state.ended) {\n state.needReadable = true;\n return 0;\n }\n\n return state.length;\n} // you can override either this method, or the async _read(n) below.\n\n\nReadable.prototype.read = function (n) {\n debug('read', n);\n n = parseInt(n, 10);\n var state = this._readableState;\n var nOrig = n;\n if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we\n // already have a bunch of data in the buffer, then just trigger\n // the 'readable' event and move on.\n\n if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n debug('read: emitReadable', state.length, state.ended);\n if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n return null;\n }\n\n n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.\n\n if (n === 0 && state.ended) {\n if (state.length === 0) endReadable(this);\n return null;\n } // All the actual chunk generation logic needs to be\n // *below* the call to _read. The reason is that in certain\n // synthetic stream cases, such as passthrough streams, _read\n // may be a completely synchronous operation which may change\n // the state of the read buffer, providing enough data when\n // before there was *not* enough.\n //\n // So, the steps are:\n // 1. Figure out what the state of things will be after we do\n // a read from the buffer.\n //\n // 2. If that resulting state will trigger a _read, then call _read.\n // Note that this may be asynchronous, or synchronous. Yes, it is\n // deeply ugly to write APIs this way, but that still doesn't mean\n // that the Readable class should behave improperly, as streams are\n // designed to be sync/async agnostic.\n // Take note if the _read call is sync or async (ie, if the read call\n // has returned yet), so that we know whether or not it's safe to emit\n // 'readable' etc.\n //\n // 3. Actually pull the requested chunks out of the buffer and return.\n // if we need a readable event, then we need to do some reading.\n\n\n var doRead = state.needReadable;\n debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some\n\n if (state.length === 0 || state.length - n < state.highWaterMark) {\n doRead = true;\n debug('length less than watermark', doRead);\n } // however, if we've ended, then there's no point, and if we're already\n // reading, then it's unnecessary.\n\n\n if (state.ended || state.reading) {\n doRead = false;\n debug('reading or ended', doRead);\n } else if (doRead) {\n debug('do read');\n state.reading = true;\n state.sync = true; // if the length is currently zero, then we *need* a readable event.\n\n if (state.length === 0) state.needReadable = true; // call internal read method\n\n this._read(state.highWaterMark);\n\n state.sync = false; // If _read pushed data synchronously, then `reading` will be false,\n // and we need to re-evaluate how much data we can return to the user.\n\n if (!state.reading) n = howMuchToRead(nOrig, state);\n }\n\n var ret;\n if (n > 0) ret = fromList(n, state);else ret = null;\n\n if (ret === null) {\n state.needReadable = true;\n n = 0;\n } else {\n state.length -= n;\n state.awaitDrain = 0;\n }\n\n if (state.length === 0) {\n // If we have nothing in the buffer, then we want to know\n // as soon as we *do* get something into the buffer.\n if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.\n\n if (nOrig !== n && state.ended) endReadable(this);\n }\n\n if (ret !== null) this.emit('data', ret);\n return ret;\n};\n\nfunction onEofChunk(stream, state) {\n if (state.ended) return;\n\n if (state.decoder) {\n var chunk = state.decoder.end();\n\n if (chunk && chunk.length) {\n state.buffer.push(chunk);\n state.length += state.objectMode ? 1 : chunk.length;\n }\n }\n\n state.ended = true;\n\n if (state.sync) {\n // if we are sync, wait until next tick to emit the data.\n // Otherwise we risk emitting data in the flow()\n // the readable code triggers during a read() call\n emitReadable(stream);\n } else {\n // emit 'readable' now to make sure it gets picked up.\n state.needReadable = false;\n\n if (!state.emittedReadable) {\n state.emittedReadable = true;\n emitReadable_(stream);\n }\n }\n} // Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow. This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\n\n\nfunction emitReadable(stream) {\n var state = stream._readableState;\n state.needReadable = false;\n\n if (!state.emittedReadable) {\n debug('emitReadable', state.flowing);\n state.emittedReadable = true;\n process.nextTick(emitReadable_, stream);\n }\n}\n\nfunction emitReadable_(stream) {\n var state = stream._readableState;\n debug('emitReadable_', state.destroyed, state.length, state.ended);\n\n if (!state.destroyed && (state.length || state.ended)) {\n stream.emit('readable');\n } // The stream needs another readable event if\n // 1. It is not flowing, as the flow mechanism will take\n // care of it.\n // 2. It is not ended.\n // 3. It is below the highWaterMark, so we can schedule\n // another readable later.\n\n\n state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n flow(stream);\n} // at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data. that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\n\n\nfunction maybeReadMore(stream, state) {\n if (!state.readingMore) {\n state.readingMore = true;\n process.nextTick(maybeReadMore_, stream, state);\n }\n}\n\nfunction maybeReadMore_(stream, state) {\n // Attempt to read more data if we should.\n //\n // The conditions for reading more data are (one of):\n // - Not enough data buffered (state.length < state.highWaterMark). The loop\n // is responsible for filling the buffer with enough data if such data\n // is available. If highWaterMark is 0 and we are not in the flowing mode\n // we should _not_ attempt to buffer any extra data. We'll get more data\n // when the stream consumer calls read() instead.\n // - No data in the buffer, and the stream is in flowing mode. In this mode\n // the loop below is responsible for ensuring read() is called. Failing to\n // call read here would abort the flow and there's no other mechanism for\n // continuing the flow if the stream consumer has just subscribed to the\n // 'data' event.\n //\n // In addition to the above conditions to keep reading data, the following\n // conditions prevent the data from being read:\n // - The stream has ended (state.ended).\n // - There is already a pending 'read' operation (state.reading). This is a\n // case where the the stream has called the implementation defined _read()\n // method, but they are processing the call asynchronously and have _not_\n // called push() with new data. In this case we skip performing more\n // read()s. The execution ends in this method again after the _read() ends\n // up calling push() with more data.\n while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n var len = state.length;\n debug('maybeReadMore read 0');\n stream.read(0);\n if (len === state.length) // didn't get any data, stop spinning.\n break;\n }\n\n state.readingMore = false;\n} // abstract method. to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\n\n\nReadable.prototype._read = function (n) {\n this.emit('error', new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n var src = this;\n var state = this._readableState;\n\n switch (state.pipesCount) {\n case 0:\n state.pipes = dest;\n break;\n\n case 1:\n state.pipes = [state.pipes, dest];\n break;\n\n default:\n state.pipes.push(dest);\n break;\n }\n\n state.pipesCount += 1;\n debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n var endFn = doEnd ? onend : unpipe;\n if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\n dest.on('unpipe', onunpipe);\n\n function onunpipe(readable, unpipeInfo) {\n debug('onunpipe');\n\n if (readable === src) {\n if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n unpipeInfo.hasUnpiped = true;\n cleanup();\n }\n }\n }\n\n function onend() {\n debug('onend');\n dest.end();\n } // when the dest drains, it reduces the awaitDrain counter\n // on the source. This would be more elegant with a .once()\n // handler in flow(), but adding and removing repeatedly is\n // too slow.\n\n\n var ondrain = pipeOnDrain(src);\n dest.on('drain', ondrain);\n var cleanedUp = false;\n\n function cleanup() {\n debug('cleanup'); // cleanup event handlers once the pipe is broken\n\n dest.removeListener('close', onclose);\n dest.removeListener('finish', onfinish);\n dest.removeListener('drain', ondrain);\n dest.removeListener('error', onerror);\n dest.removeListener('unpipe', onunpipe);\n src.removeListener('end', onend);\n src.removeListener('end', unpipe);\n src.removeListener('data', ondata);\n cleanedUp = true; // if the reader is waiting for a drain event from this\n // specific writer, then it would cause it to never start\n // flowing again.\n // So, if this is awaiting a drain, then we just call it now.\n // If we don't know, then assume that we are waiting for one.\n\n if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n }\n\n src.on('data', ondata);\n\n function ondata(chunk) {\n debug('ondata');\n var ret = dest.write(chunk);\n debug('dest.write', ret);\n\n if (ret === false) {\n // If the user unpiped during `dest.write()`, it is possible\n // to get stuck in a permanently paused state if that write\n // also returned false.\n // => Check whether `dest` is still a piping destination.\n if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n debug('false write response, pause', state.awaitDrain);\n state.awaitDrain++;\n }\n\n src.pause();\n }\n } // if the dest has an error, then stop piping into it.\n // however, don't suppress the throwing behavior for this.\n\n\n function onerror(er) {\n debug('onerror', er);\n unpipe();\n dest.removeListener('error', onerror);\n if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n } // Make sure our error handler is attached before userland ones.\n\n\n prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.\n\n function onclose() {\n dest.removeListener('finish', onfinish);\n unpipe();\n }\n\n dest.once('close', onclose);\n\n function onfinish() {\n debug('onfinish');\n dest.removeListener('close', onclose);\n unpipe();\n }\n\n dest.once('finish', onfinish);\n\n function unpipe() {\n debug('unpipe');\n src.unpipe(dest);\n } // tell the dest that it's being piped to\n\n\n dest.emit('pipe', src); // start the flow if it hasn't been started already.\n\n if (!state.flowing) {\n debug('pipe resume');\n src.resume();\n }\n\n return dest;\n};\n\nfunction pipeOnDrain(src) {\n return function pipeOnDrainFunctionResult() {\n var state = src._readableState;\n debug('pipeOnDrain', state.awaitDrain);\n if (state.awaitDrain) state.awaitDrain--;\n\n if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n state.flowing = true;\n flow(src);\n }\n };\n}\n\nReadable.prototype.unpipe = function (dest) {\n var state = this._readableState;\n var unpipeInfo = {\n hasUnpiped: false\n }; // if we're not piping anywhere, then do nothing.\n\n if (state.pipesCount === 0) return this; // just one destination. most common case.\n\n if (state.pipesCount === 1) {\n // passed in one, but it's not the right one.\n if (dest && dest !== state.pipes) return this;\n if (!dest) dest = state.pipes; // got a match.\n\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n if (dest) dest.emit('unpipe', this, unpipeInfo);\n return this;\n } // slow case. multiple pipe destinations.\n\n\n if (!dest) {\n // remove all.\n var dests = state.pipes;\n var len = state.pipesCount;\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n\n for (var i = 0; i < len; i++) {\n dests[i].emit('unpipe', this, {\n hasUnpiped: false\n });\n }\n\n return this;\n } // try to find the right one.\n\n\n var index = indexOf(state.pipes, dest);\n if (index === -1) return this;\n state.pipes.splice(index, 1);\n state.pipesCount -= 1;\n if (state.pipesCount === 1) state.pipes = state.pipes[0];\n dest.emit('unpipe', this, unpipeInfo);\n return this;\n}; // set up data events if they are asked for\n// Ensure readable listeners eventually get something\n\n\nReadable.prototype.on = function (ev, fn) {\n var res = Stream.prototype.on.call(this, ev, fn);\n var state = this._readableState;\n\n if (ev === 'data') {\n // update readableListening so that resume() may be a no-op\n // a few lines down. This is needed to support once('readable').\n state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused\n\n if (state.flowing !== false) this.resume();\n } else if (ev === 'readable') {\n if (!state.endEmitted && !state.readableListening) {\n state.readableListening = state.needReadable = true;\n state.flowing = false;\n state.emittedReadable = false;\n debug('on readable', state.length, state.reading);\n\n if (state.length) {\n emitReadable(this);\n } else if (!state.reading) {\n process.nextTick(nReadingNextTick, this);\n }\n }\n }\n\n return res;\n};\n\nReadable.prototype.addListener = Readable.prototype.on;\n\nReadable.prototype.removeListener = function (ev, fn) {\n var res = Stream.prototype.removeListener.call(this, ev, fn);\n\n if (ev === 'readable') {\n // We need to check if there is someone still listening to\n // readable and reset the state. However this needs to happen\n // after readable has been emitted but before I/O (nextTick) to\n // support once('readable', fn) cycles. This means that calling\n // resume within the same tick will have no\n // effect.\n process.nextTick(updateReadableListening, this);\n }\n\n return res;\n};\n\nReadable.prototype.removeAllListeners = function (ev) {\n var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n\n if (ev === 'readable' || ev === undefined) {\n // We need to check if there is someone still listening to\n // readable and reset the state. However this needs to happen\n // after readable has been emitted but before I/O (nextTick) to\n // support once('readable', fn) cycles. This means that calling\n // resume within the same tick will have no\n // effect.\n process.nextTick(updateReadableListening, this);\n }\n\n return res;\n};\n\nfunction updateReadableListening(self) {\n var state = self._readableState;\n state.readableListening = self.listenerCount('readable') > 0;\n\n if (state.resumeScheduled && !state.paused) {\n // flowing needs to be set to true now, otherwise\n // the upcoming resume will not flow.\n state.flowing = true; // crude way to check if we should resume\n } else if (self.listenerCount('data') > 0) {\n self.resume();\n }\n}\n\nfunction nReadingNextTick(self) {\n debug('readable nexttick read 0');\n self.read(0);\n} // pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\n\n\nReadable.prototype.resume = function () {\n var state = this._readableState;\n\n if (!state.flowing) {\n debug('resume'); // we flow only if there is no one listening\n // for readable, but we still have to call\n // resume()\n\n state.flowing = !state.readableListening;\n resume(this, state);\n }\n\n state.paused = false;\n return this;\n};\n\nfunction resume(stream, state) {\n if (!state.resumeScheduled) {\n state.resumeScheduled = true;\n process.nextTick(resume_, stream, state);\n }\n}\n\nfunction resume_(stream, state) {\n debug('resume', state.reading);\n\n if (!state.reading) {\n stream.read(0);\n }\n\n state.resumeScheduled = false;\n stream.emit('resume');\n flow(stream);\n if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n debug('call pause flowing=%j', this._readableState.flowing);\n\n if (this._readableState.flowing !== false) {\n debug('pause');\n this._readableState.flowing = false;\n this.emit('pause');\n }\n\n this._readableState.paused = true;\n return this;\n};\n\nfunction flow(stream) {\n var state = stream._readableState;\n debug('flow', state.flowing);\n\n while (state.flowing && stream.read() !== null) {\n ;\n }\n} // wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\n\n\nReadable.prototype.wrap = function (stream) {\n var _this = this;\n\n var state = this._readableState;\n var paused = false;\n stream.on('end', function () {\n debug('wrapped end');\n\n if (state.decoder && !state.ended) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length) _this.push(chunk);\n }\n\n _this.push(null);\n });\n stream.on('data', function (chunk) {\n debug('wrapped data');\n if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode\n\n if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n var ret = _this.push(chunk);\n\n if (!ret) {\n paused = true;\n stream.pause();\n }\n }); // proxy all the other methods.\n // important when wrapping filters and duplexes.\n\n for (var i in stream) {\n if (this[i] === undefined && typeof stream[i] === 'function') {\n this[i] = function methodWrap(method) {\n return function methodWrapReturnFunction() {\n return stream[method].apply(stream, arguments);\n };\n }(i);\n }\n } // proxy certain important events.\n\n\n for (var n = 0; n < kProxyEvents.length; n++) {\n stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n } // when we try to consume some more bytes, simply unpause the\n // underlying stream.\n\n\n this._read = function (n) {\n debug('wrapped _read', n);\n\n if (paused) {\n paused = false;\n stream.resume();\n }\n };\n\n return this;\n};\n\nif (typeof Symbol === 'function') {\n Readable.prototype[Symbol.asyncIterator] = function () {\n emitExperimentalWarning('Readable[Symbol.asyncIterator]');\n\n if (createReadableStreamAsyncIterator === undefined) {\n createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n }\n\n return createReadableStreamAsyncIterator(this);\n };\n}\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.highWaterMark;\n }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState && this._readableState.buffer;\n }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.flowing;\n },\n set: function set(state) {\n if (this._readableState) {\n this._readableState.flowing = state;\n }\n }\n}); // exposed for testing purposes only.\n\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.length;\n }\n}); // Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\nfunction fromList(n, state) {\n // nothing buffered\n if (state.length === 0) return null;\n var ret;\n if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n // read it all, truncate the list\n if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);\n state.buffer.clear();\n } else {\n // read part of list\n ret = state.buffer.consume(n, state.decoder);\n }\n return ret;\n}\n\nfunction endReadable(stream) {\n var state = stream._readableState;\n debug('endReadable', state.endEmitted);\n\n if (!state.endEmitted) {\n state.ended = true;\n process.nextTick(endReadableNT, state, stream);\n }\n}\n\nfunction endReadableNT(state, stream) {\n debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.\n\n if (!state.endEmitted && state.length === 0) {\n state.endEmitted = true;\n stream.readable = false;\n stream.emit('end');\n }\n}\n\nfunction indexOf(xs, x) {\n for (var i = 0, l = xs.length; i < l; i++) {\n if (xs[i] === x) return i;\n }\n\n return -1;\n}","module.exports = require('events').EventEmitter;\n","'use strict'; // undocumented cb() API, needed for core, not for public API\n\nfunction destroy(err, cb) {\n var _this = this;\n\n var readableDestroyed = this._readableState && this._readableState.destroyed;\n var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n if (readableDestroyed || writableDestroyed) {\n if (cb) {\n cb(err);\n } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n process.nextTick(emitErrorNT, this, err);\n }\n\n return this;\n } // we set destroyed to true before firing error callbacks in order\n // to make it re-entrance safe in case destroy() is called within callbacks\n\n\n if (this._readableState) {\n this._readableState.destroyed = true;\n } // if this is a duplex stream mark the writable part as destroyed as well\n\n\n if (this._writableState) {\n this._writableState.destroyed = true;\n }\n\n this._destroy(err || null, function (err) {\n if (!cb && err) {\n process.nextTick(emitErrorAndCloseNT, _this, err);\n\n if (_this._writableState) {\n _this._writableState.errorEmitted = true;\n }\n } else if (cb) {\n process.nextTick(emitCloseNT, _this);\n cb(err);\n } else {\n process.nextTick(emitCloseNT, _this);\n }\n });\n\n return this;\n}\n\nfunction emitErrorAndCloseNT(self, err) {\n emitErrorNT(self, err);\n emitCloseNT(self);\n}\n\nfunction emitCloseNT(self) {\n if (self._writableState && !self._writableState.emitClose) return;\n if (self._readableState && !self._readableState.emitClose) return;\n self.emit('close');\n}\n\nfunction undestroy() {\n if (this._readableState) {\n this._readableState.destroyed = false;\n this._readableState.reading = false;\n this._readableState.ended = false;\n this._readableState.endEmitted = false;\n }\n\n if (this._writableState) {\n this._writableState.destroyed = false;\n this._writableState.ended = false;\n this._writableState.ending = false;\n this._writableState.finalCalled = false;\n this._writableState.prefinished = false;\n this._writableState.finished = false;\n this._writableState.errorEmitted = false;\n }\n}\n\nfunction emitErrorNT(self, err) {\n self.emit('error', err);\n}\n\nmodule.exports = {\n destroy: destroy,\n undestroy: undestroy\n};","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\n\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\n\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n\n if (hwm != null) {\n if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n var name = isDuplex ? duplexKey : 'highWaterMark';\n throw new ERR_INVALID_OPT_VALUE(name, hwm);\n }\n\n return Math.floor(hwm);\n } // Default value\n\n\n return state.objectMode ? 16 : 16 * 1024;\n}\n\nmodule.exports = {\n getHighWaterMark: getHighWaterMark\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n'use strict';\n\nmodule.exports = Writable;\n/* */\n\nfunction WriteReq(chunk, encoding, cb) {\n this.chunk = chunk;\n this.encoding = encoding;\n this.callback = cb;\n this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n var _this = this;\n\n this.next = null;\n this.entry = null;\n\n this.finish = function () {\n onCorkedFinish(_this, state);\n };\n}\n/* */\n\n/**/\n\n\nvar Duplex;\n/**/\n\nWritable.WritableState = WritableState;\n/**/\n\nvar internalUtil = {\n deprecate: require('util-deprecate')\n};\n/**/\n\n/**/\n\nvar Stream = require('./internal/streams/stream');\n/**/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n Duplex = Duplex || require('./_stream_duplex');\n options = options || {}; // Duplex streams are both readable and writable, but share\n // the same options object.\n // However, some cases require setting options to different\n // values for the readable and the writable sides of the duplex stream,\n // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n\n if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n // contains buffers or objects.\n\n this.objectMode = !!options.objectMode;\n if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false\n // Note: 0 is a valid value, means that we always return false if\n // the entire buffer is not flushed immediately on write()\n\n this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n this.finalCalled = false; // drain event flag.\n\n this.needDrain = false; // at the start of calling end()\n\n this.ending = false; // when end() has been called, and returned\n\n this.ended = false; // when 'finish' is emitted\n\n this.finished = false; // has it been destroyed\n\n this.destroyed = false; // should we decode strings into buffers before passing to _write?\n // this is here so that some node-core streams can optimize string\n // handling at a lower level.\n\n var noDecode = options.decodeStrings === false;\n this.decodeStrings = !noDecode; // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n\n this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement\n // of how much we're waiting to get pushed to some underlying\n // socket or file.\n\n this.length = 0; // a flag to see when we're in the middle of a write.\n\n this.writing = false; // when true all writes will be buffered until .uncork() call\n\n this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,\n // or on a later tick. We set this to true at first, because any\n // actions that shouldn't happen until \"later\" should generally also\n // not happen before the first write call.\n\n this.sync = true; // a flag to know if we're processing previously buffered items, which\n // may call the _write() callback in the same tick, so that we don't\n // end up in an overlapped onwrite situation.\n\n this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n this.onwrite = function (er) {\n onwrite(stream, er);\n }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n this.writecb = null; // the amount that is being written when _write is called.\n\n this.writelen = 0;\n this.bufferedRequest = null;\n this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n // this must be 0 before 'finish' can be emitted\n\n this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n // This is relevant for synchronous Transform streams\n\n this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n this.emitClose = options.emitClose !== false; // count buffered requests\n\n this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n // one allocated and free to use, and we maintain at most two\n\n this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n var current = this.bufferedRequest;\n var out = [];\n\n while (current) {\n out.push(current);\n current = current.next;\n }\n\n return out;\n};\n\n(function () {\n try {\n Object.defineProperty(WritableState.prototype, 'buffer', {\n get: internalUtil.deprecate(function writableStateBufferGetter() {\n return this.getBuffer();\n }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n });\n } catch (_) {}\n})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n realHasInstance = Function.prototype[Symbol.hasInstance];\n Object.defineProperty(Writable, Symbol.hasInstance, {\n value: function value(object) {\n if (realHasInstance.call(this, object)) return true;\n if (this !== Writable) return false;\n return object && object._writableState instanceof WritableState;\n }\n });\n} else {\n realHasInstance = function realHasInstance(object) {\n return object instanceof this;\n };\n}\n\nfunction Writable(options) {\n Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.\n // `realHasInstance` is necessary because using plain `instanceof`\n // would return false, as no `_writableState` property is attached.\n // Trying to use the custom `instanceof` for Writable here will also break the\n // Node.js LazyTransform implementation, which has a non-trivial getter for\n // `_writableState` that would lead to infinite recursion.\n // Checking for a Stream.Duplex instance is faster here instead of inside\n // the WritableState constructor, at least with V8 6.5\n\n var isDuplex = this instanceof Duplex;\n if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n this._writableState = new WritableState(options, this, isDuplex); // legacy.\n\n this.writable = true;\n\n if (options) {\n if (typeof options.write === 'function') this._write = options.write;\n if (typeof options.writev === 'function') this._writev = options.writev;\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n if (typeof options.final === 'function') this._final = options.final;\n }\n\n Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n this.emit('error', new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n stream.emit('error', er);\n process.nextTick(cb, er);\n} // Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n var er;\n\n if (chunk === null) {\n er = new ERR_STREAM_NULL_VALUES();\n } else if (typeof chunk !== 'string' && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n }\n\n if (er) {\n stream.emit('error', er);\n process.nextTick(cb, er);\n return false;\n }\n\n return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n var state = this._writableState;\n var ret = false;\n\n var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n if (isBuf && !Buffer.isBuffer(chunk)) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n if (typeof cb !== 'function') cb = nop;\n if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n state.pendingcb++;\n ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n }\n return ret;\n};\n\nWritable.prototype.cork = function () {\n this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n var state = this._writableState;\n\n if (state.corked) {\n state.corked--;\n if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n // node::ParseEncoding() requires lower case.\n if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n this._writableState.defaultEncoding = encoding;\n return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n});\n\nfunction decodeChunk(state, chunk, encoding) {\n if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n chunk = Buffer.from(chunk, encoding);\n }\n\n return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n}); // if we're already writing something, then just put this\n// in the queue, and wait our turn. Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n if (!isBuf) {\n var newChunk = decodeChunk(state, chunk, encoding);\n\n if (chunk !== newChunk) {\n isBuf = true;\n encoding = 'buffer';\n chunk = newChunk;\n }\n }\n\n var len = state.objectMode ? 1 : chunk.length;\n state.length += len;\n var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\n if (!ret) state.needDrain = true;\n\n if (state.writing || state.corked) {\n var last = state.lastBufferedRequest;\n state.lastBufferedRequest = {\n chunk: chunk,\n encoding: encoding,\n isBuf: isBuf,\n callback: cb,\n next: null\n };\n\n if (last) {\n last.next = state.lastBufferedRequest;\n } else {\n state.bufferedRequest = state.lastBufferedRequest;\n }\n\n state.bufferedRequestCount += 1;\n } else {\n doWrite(stream, state, false, len, chunk, encoding, cb);\n }\n\n return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n state.writelen = len;\n state.writecb = cb;\n state.writing = true;\n state.sync = true;\n if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n --state.pendingcb;\n\n if (sync) {\n // defer the callback if we are being called synchronously\n // to avoid piling up things on the stack\n process.nextTick(cb, er); // this can emit finish, and it will always happen\n // after error\n\n process.nextTick(finishMaybe, stream, state);\n stream._writableState.errorEmitted = true;\n stream.emit('error', er);\n } else {\n // the caller expect this to happen before if\n // it is async\n cb(er);\n stream._writableState.errorEmitted = true;\n stream.emit('error', er); // this can emit finish, but finish must\n // always follow error\n\n finishMaybe(stream, state);\n }\n}\n\nfunction onwriteStateUpdate(state) {\n state.writing = false;\n state.writecb = null;\n state.length -= state.writelen;\n state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n var state = stream._writableState;\n var sync = state.sync;\n var cb = state.writecb;\n if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n onwriteStateUpdate(state);\n if (er) onwriteError(stream, state, sync, er, cb);else {\n // Check if we're actually ready to finish, but don't emit yet\n var finished = needFinish(state) || stream.destroyed;\n\n if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n clearBuffer(stream, state);\n }\n\n if (sync) {\n process.nextTick(afterWrite, stream, state, finished, cb);\n } else {\n afterWrite(stream, state, finished, cb);\n }\n }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n if (!finished) onwriteDrain(stream, state);\n state.pendingcb--;\n cb();\n finishMaybe(stream, state);\n} // Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\n\n\nfunction onwriteDrain(stream, state) {\n if (state.length === 0 && state.needDrain) {\n state.needDrain = false;\n stream.emit('drain');\n }\n} // if there's something in the buffer waiting, then process it\n\n\nfunction clearBuffer(stream, state) {\n state.bufferProcessing = true;\n var entry = state.bufferedRequest;\n\n if (stream._writev && entry && entry.next) {\n // Fast case, write everything using _writev()\n var l = state.bufferedRequestCount;\n var buffer = new Array(l);\n var holder = state.corkedRequestsFree;\n holder.entry = entry;\n var count = 0;\n var allBuffers = true;\n\n while (entry) {\n buffer[count] = entry;\n if (!entry.isBuf) allBuffers = false;\n entry = entry.next;\n count += 1;\n }\n\n buffer.allBuffers = allBuffers;\n doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n // as the hot path ends with doWrite\n\n state.pendingcb++;\n state.lastBufferedRequest = null;\n\n if (holder.next) {\n state.corkedRequestsFree = holder.next;\n holder.next = null;\n } else {\n state.corkedRequestsFree = new CorkedRequest(state);\n }\n\n state.bufferedRequestCount = 0;\n } else {\n // Slow case, write chunks one-by-one\n while (entry) {\n var chunk = entry.chunk;\n var encoding = entry.encoding;\n var cb = entry.callback;\n var len = state.objectMode ? 1 : chunk.length;\n doWrite(stream, state, false, len, chunk, encoding, cb);\n entry = entry.next;\n state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then\n // it means that we need to wait until it does.\n // also, that means that the chunk and cb are currently\n // being processed, so move the buffer counter past them.\n\n if (state.writing) {\n break;\n }\n }\n\n if (entry === null) state.lastBufferedRequest = null;\n }\n\n state.bufferedRequest = entry;\n state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n var state = this._writableState;\n\n if (typeof chunk === 'function') {\n cb = chunk;\n chunk = null;\n encoding = null;\n } else if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks\n\n if (state.corked) {\n state.corked = 1;\n this.uncork();\n } // ignore unnecessary end() calls.\n\n\n if (!state.ending) endWritable(this, state, cb);\n return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n});\n\nfunction needFinish(state) {\n return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n stream._final(function (err) {\n state.pendingcb--;\n\n if (err) {\n stream.emit('error', err);\n }\n\n state.prefinished = true;\n stream.emit('prefinish');\n finishMaybe(stream, state);\n });\n}\n\nfunction prefinish(stream, state) {\n if (!state.prefinished && !state.finalCalled) {\n if (typeof stream._final === 'function' && !state.destroyed) {\n state.pendingcb++;\n state.finalCalled = true;\n process.nextTick(callFinal, stream, state);\n } else {\n state.prefinished = true;\n stream.emit('prefinish');\n }\n }\n}\n\nfunction finishMaybe(stream, state) {\n var need = needFinish(state);\n\n if (need) {\n prefinish(stream, state);\n\n if (state.pendingcb === 0) {\n state.finished = true;\n stream.emit('finish');\n }\n }\n\n return need;\n}\n\nfunction endWritable(stream, state, cb) {\n state.ending = true;\n finishMaybe(stream, state);\n\n if (cb) {\n if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n }\n\n state.ended = true;\n stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n var entry = corkReq.entry;\n corkReq.entry = null;\n\n while (entry) {\n var cb = entry.callback;\n state.pendingcb--;\n cb(err);\n entry = entry.next;\n } // reuse the free corkReq.\n\n\n state.corkedRequestsFree.next = corkReq;\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._writableState === undefined) {\n return false;\n }\n\n return this._writableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._writableState) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._writableState.destroyed = value;\n }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n cb(err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a transform stream is a readable/writable stream where you do\n// something with the data. Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored. (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation. For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes. When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up. When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer. When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks. If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk. However,\n// a pathological inflate type of transform can cause excessive buffering\n// here. For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output. In this case, you could write a very small\n// amount of input, and end up with a very large amount of output. In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform. A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n'use strict';\n\nmodule.exports = Transform;\n\nvar _require$codes = require('../errors').codes,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\n\nvar Duplex = require('./_stream_duplex');\n\nrequire('inherits')(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n var ts = this._transformState;\n ts.transforming = false;\n var cb = ts.writecb;\n\n if (cb === null) {\n return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n }\n\n ts.writechunk = null;\n ts.writecb = null;\n if (data != null) // single equals check for both `null` and `undefined`\n this.push(data);\n cb(er);\n var rs = this._readableState;\n rs.reading = false;\n\n if (rs.needReadable || rs.length < rs.highWaterMark) {\n this._read(rs.highWaterMark);\n }\n}\n\nfunction Transform(options) {\n if (!(this instanceof Transform)) return new Transform(options);\n Duplex.call(this, options);\n this._transformState = {\n afterTransform: afterTransform.bind(this),\n needTransform: false,\n transforming: false,\n writecb: null,\n writechunk: null,\n writeencoding: null\n }; // start out asking for a readable event once data is transformed.\n\n this._readableState.needReadable = true; // we have implemented the _read method, and done the other things\n // that Readable wants before the first _read call, so unset the\n // sync guard flag.\n\n this._readableState.sync = false;\n\n if (options) {\n if (typeof options.transform === 'function') this._transform = options.transform;\n if (typeof options.flush === 'function') this._flush = options.flush;\n } // When the writable side finishes, then flush out anything remaining.\n\n\n this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n var _this = this;\n\n if (typeof this._flush === 'function' && !this._readableState.destroyed) {\n this._flush(function (er, data) {\n done(_this, er, data);\n });\n } else {\n done(this, null, null);\n }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n this._transformState.needTransform = false;\n return Duplex.prototype.push.call(this, chunk, encoding);\n}; // This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side. You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk. If you pass\n// an error, then that'll put the hurt on the whole operation. If you\n// never call cb(), then you'll never get another chunk.\n\n\nTransform.prototype._transform = function (chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n var ts = this._transformState;\n ts.writecb = cb;\n ts.writechunk = chunk;\n ts.writeencoding = encoding;\n\n if (!ts.transforming) {\n var rs = this._readableState;\n if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n }\n}; // Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\n\n\nTransform.prototype._read = function (n) {\n var ts = this._transformState;\n\n if (ts.writechunk !== null && !ts.transforming) {\n ts.transforming = true;\n\n this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n } else {\n // mark that we need a transform, so that any data that comes in\n // will get processed, now that we've asked for it.\n ts.needTransform = true;\n }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n Duplex.prototype._destroy.call(this, err, function (err2) {\n cb(err2);\n });\n};\n\nfunction done(stream, er, data) {\n if (er) return stream.emit('error', er);\n if (data != null) // single equals check for both `null` and `undefined`\n stream.push(data); // TODO(BridgeAR): Write a test for these two error cases\n // if there's nothing in the write buffer, then that means\n // that nothing more will ever be provided\n\n if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n return stream.push(null);\n}","// render a completed PlotterToSvg object\n'use strict'\n\nvar xmlElementString = require('xml-element-string')\n\nmodule.exports = function(converter, attr, createElement) {\n var element = createElement || xmlElementString\n\n var attributes = {\n version: '1.1',\n xmlns: 'http://www.w3.org/2000/svg',\n 'xmlns:xlink': 'http://www.w3.org/1999/xlink',\n 'stroke-linecap': 'round',\n 'stroke-linejoin': 'round',\n 'stroke-width': '0',\n 'fill-rule': 'evenodd',\n width: converter.width + converter.units,\n height: converter.height + converter.units,\n viewBox: converter.viewBox.join(' '),\n }\n\n if (typeof attr === 'string') attr = {id: attr}\n\n Object.keys(attr || {}).forEach(function(key) {\n var value = attr[key]\n\n if (value != null) {\n attributes[key] = value\n }\n })\n\n var children = []\n\n if (converter.layer.length) {\n if (converter.defs.length) {\n children.push(element('defs', {}, converter.defs))\n }\n\n var yTranslate = converter.viewBox[3] + 2 * converter.viewBox[1]\n var transform = 'translate(0,' + yTranslate + ') scale(1,-1)'\n\n children.push(\n element(\n 'g',\n {\n transform: transform,\n fill: 'currentColor',\n stroke: 'currentColor',\n },\n converter.layer\n )\n )\n }\n\n return element('svg', attributes, children)\n}\n","// board color defaults and css generation\n'use strict'\n\nvar colorString = require('color-string')\n\nvar LAYER_IDS = ['fr4', 'cu', 'cf', 'sm', 'ss', 'sp', 'out']\n\nvar DEFAULTS = {\n fr4: '#b7c4c8',\n cu: '#ffffff',\n cf: '#cc9933',\n sm: '#000000',\n ss: '#ff0000',\n sp: '#dddddd',\n out: '#002255',\n}\n\nfunction getColor(overrides) {\n overrides = overrides || {}\n\n return LAYER_IDS.reduce(function(color, id) {\n color[id] = overrides[id] || DEFAULTS[id]\n return color\n }, {})\n}\n\nfunction getStyleElement(element, prefix, side, color) {\n return element('style', {}, [\n LAYER_IDS.map(function(id) {\n var selector = '.' + prefix + id\n var style = colorToCssString(color[id])\n return selector + ' {' + style + '}'\n }).join('\\n'),\n ])\n}\n\nfunction colorToCssString(color) {\n var parsedColor = colorString.get(color)\n\n if (!parsedColor) return ''\n\n var css = 'color: '\n var components = parsedColor.value.slice(0, 3)\n var alpha = parsedColor.value[3] != null ? parsedColor.value[3] : 1\n\n if (parsedColor.model === 'rgb') {\n css += colorString.to.hex(components).toLowerCase()\n } else {\n css += colorString.to[parsedColor.model](components).toLowerCase()\n }\n\n if (alpha !== 1) {\n css += '; opacity: ' + alpha\n }\n\n return css + ';'\n}\n\nmodule.exports = {getColor: getColor, getStyleElement: getStyleElement}\n","module.exports = runParallel\n\nfunction runParallel (tasks, cb) {\n var results, pending, keys\n var isSync = true\n\n if (Array.isArray(tasks)) {\n results = []\n pending = tasks.length\n } else {\n keys = Object.keys(tasks)\n results = {}\n pending = keys.length\n }\n\n function done (err) {\n function end () {\n if (cb) cb(err, results)\n cb = null\n }\n if (isSync) process.nextTick(end)\n else end()\n }\n\n function each (i, err, result) {\n results[i] = result\n if (--pending === 0 || err) {\n done(err)\n }\n }\n\n if (!pending) {\n // empty\n done(null)\n } else if (keys) {\n // object\n keys.forEach(function (key) {\n tasks[key](function (err, result) { each(key, err, result) })\n })\n } else {\n // array\n tasks.forEach(function (task, i) {\n task(function (err, result) { each(i, err, result) })\n })\n }\n\n isSync = false\n}\n","module.exports = runWaterfall\n\nfunction runWaterfall (tasks, cb) {\n var current = 0\n var isSync = true\n\n function done (err, args) {\n function end () {\n args = args ? [].concat(err, args) : [ err ]\n if (cb) cb.apply(undefined, args)\n }\n if (isSync) process.nextTick(end)\n else end()\n }\n\n function each (err) {\n var args = Array.prototype.slice.call(arguments, 1)\n if (++current >= tasks.length || err) {\n done(err, args)\n } else {\n tasks[current].apply(undefined, [].concat(args, each))\n }\n }\n\n if (tasks.length) {\n tasks[0](each)\n } else {\n done(null)\n }\n\n isSync = false\n}\n","// gerber to svg transform stream\n'use strict'\n\nvar xid = require('@tracespace/xml-id')\nvar gerberParser = require('gerber-parser')\nvar gerberPlotter = require('gerber-plotter')\nvar xmlElementString = require('xml-element-string')\n\nvar PlotterToSvg = require('./lib/plotter-to-svg')\nvar render = require('./render')\nvar clone = require('./clone')\n\nvar parseOptions = function(options) {\n if (typeof options === 'string') {\n options = {id: options}\n } else if (!options) {\n options = {}\n }\n\n var opts = {\n id: xid.ensure(options.id),\n attributes: options.attributes || {},\n createElement: options.createElement || xmlElementString,\n objectMode: options.objectMode == null ? false : options.objectMode,\n parser: {\n places: options.places,\n zero: options.zero,\n filetype: options.filetype,\n },\n plotter: {\n units: options.units,\n backupUnits: options.backupUnits,\n nota: options.nota,\n backupNota: options.backupNota,\n optimizePaths: options.optimizePaths,\n plotAsOutline: options.plotAsOutline,\n },\n }\n\n return opts\n}\n\nmodule.exports = function gerberConverterFactory(gerber, inputOpts, done) {\n if (typeof inputOpts === 'function') {\n done = inputOpts\n inputOpts = null\n }\n\n var opts = parseOptions(inputOpts)\n var callbackMode = done != null\n\n var converter = new PlotterToSvg(\n opts.id,\n opts.attributes,\n opts.createElement,\n opts.objectMode\n )\n\n var parser = gerberParser(opts.parser)\n var plotter = gerberPlotter(opts.plotter)\n\n converter.parser = parser\n converter.plotter = plotter\n\n parser.on('warning', function handleParserWarning(w) {\n converter.emit('warning', w)\n })\n plotter.on('warning', function handlePlotterWarning(w) {\n converter.emit('warning', w)\n })\n parser.once('error', function handleParserError(e) {\n converter.emit('error', e)\n })\n plotter.once('error', function handlePlotterError(e) {\n converter.emit('error', e)\n })\n\n // expose the filetype property of the parser for convenience\n parser.once('end', function() {\n converter.filetype = parser.format.filetype\n })\n\n if (gerber.pipe) {\n gerber.setEncoding('utf8')\n gerber.pipe(parser)\n } else {\n // write the gerber string after listeners have been attached etc\n process.nextTick(function writeStringToParser() {\n parser.write(gerber)\n parser.end()\n })\n }\n\n parser.pipe(plotter).pipe(converter)\n\n // collect result in callback mode\n if (callbackMode) {\n var result = ''\n\n var finishConversion = function() {\n return done(null, result)\n }\n\n converter.on('readable', function collectStreamData() {\n var data\n\n do {\n data = converter.read() || ''\n result += data\n } while (data)\n })\n\n converter.once('end', finishConversion)\n\n converter.once('error', function(error) {\n converter.removeListener('end', finishConversion)\n\n return done(error)\n })\n }\n\n return converter\n}\n\nmodule.exports.render = render\nmodule.exports.clone = clone\n","// factory for gerber-parser class\n'use strict'\n\nvar isFinite = require('lodash.isfinite')\n\nvar Parser = require('./lib/parser')\n\nvar verifyPlaces = function(p) {\n if (\n Array.isArray(p) &&\n p.length === 2 &&\n (isFinite(p[0]) && isFinite(p[1]))\n ) {\n return p\n }\n\n throw new Error('places must be an array of two whole numbers')\n}\n\nvar verifyZero = function(z) {\n if (z === 'T' || z === 'L') {\n return z\n }\n\n throw new Error(\"zero suppression must be 'L' or 'T'\")\n}\n\nvar verifyFiletype = function(f) {\n if (f === 'gerber' || f === 'drill') {\n return f\n }\n\n throw new Error('filetype must be \"drill\" or \"gerber\"')\n}\n\nmodule.exports = function(options) {\n options = options || {}\n\n var places = options.places ? verifyPlaces(options.places) : null\n var zero = options.zero ? verifyZero(options.zero) : null\n var filetype = options.filetype ? verifyFiletype(options.filetype) : null\n\n return new Parser(places, zero, filetype)\n}\n","// generic file parser for gerber and drill files\n'use strict'\n\nvar StringDecoder = require('string_decoder').StringDecoder\nvar inherits = require('inherits')\nvar Transform = require('readable-stream').Transform\n\nvar determineFiletype = require('./_determine-filetype')\nvar getNext = require('./get-next-block')\nvar parseGerber = require('./_parse-gerber')\nvar parseDrill = require('./_parse-drill')\nvar warning = require('./_warning')\nvar drillMode = require('./_drill-mode')\n\nvar LIMIT = 65535\n\nvar Parser = function(places, zero, filetype) {\n Transform.call(this, {readableObjectMode: true})\n\n // parser properties\n this._decoder = new StringDecoder('utf8')\n this._stash = ''\n this._index = 0\n this._drillMode = drillMode.DRILL\n this._drillStash = []\n this._syncResult = null\n this.line = 0\n this.format = {places: places, zero: zero, filetype: filetype}\n}\n\ninherits(Parser, Transform)\n\nParser.prototype._process = function(chunk, filetype) {\n while (this._index < chunk.length) {\n var next = getNext(filetype, chunk, this._index)\n this._index += next.read\n this.line += next.lines\n this._stash += next.rem\n\n if (next.block) {\n if (filetype === 'gerber') {\n parseGerber(this, next.block)\n } else {\n parseDrill.parse(this, next.block)\n }\n }\n }\n}\n\nParser.prototype._transform = function(chunk, encoding, done) {\n var filetype = this.format.filetype\n\n // decode buffer to string\n chunk = this._decoder.write(chunk)\n\n // determine filetype within 65535 characters\n if (!filetype) {\n filetype = determineFiletype(chunk, this._index, LIMIT)\n this._index += chunk.length\n\n if (!filetype) {\n if (this._index >= LIMIT) {\n return done(new Error('unable to determine filetype'))\n }\n this._stash += chunk\n return done()\n } else {\n this.format.filetype = filetype\n this._index = 0\n }\n }\n\n chunk = this._stash + chunk\n this._stash = ''\n\n this._process(chunk, filetype)\n\n this._index = 0\n done()\n}\n\nParser.prototype._flush = function(done) {\n if (this.format.filetype === 'drill') {\n parseDrill.flush(this)\n }\n\n return done && done()\n}\n\nParser.prototype._push = function(data) {\n if (data.line === -1) {\n data.line = this.line\n }\n\n var pushTarget = !this._syncResult ? this : this._syncResult\n pushTarget.push(data)\n}\n\nParser.prototype._warn = function(message) {\n this.emit('warning', warning(message, this.line))\n}\n\nParser.prototype.parseSync = function(file) {\n var filetype = determineFiletype(file, this._index, 100 * LIMIT)\n this.format.filetype = filetype\n this._syncResult = []\n this._process(file, filetype)\n this._flush()\n\n return this._syncResult\n}\n\nmodule.exports = Parser\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\nexports.finished = require('./lib/internal/streams/end-of-stream.js');\nexports.pipeline = require('./lib/internal/streams/pipeline.js');\n","'use strict';\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar _require = require('buffer'),\n Buffer = _require.Buffer;\n\nvar _require2 = require('util'),\n inspect = _require2.inspect;\n\nvar custom = inspect && inspect.custom || 'inspect';\n\nfunction copyBuffer(src, target, offset) {\n Buffer.prototype.copy.call(src, target, offset);\n}\n\nmodule.exports =\n/*#__PURE__*/\nfunction () {\n function BufferList() {\n this.head = null;\n this.tail = null;\n this.length = 0;\n }\n\n var _proto = BufferList.prototype;\n\n _proto.push = function push(v) {\n var entry = {\n data: v,\n next: null\n };\n if (this.length > 0) this.tail.next = entry;else this.head = entry;\n this.tail = entry;\n ++this.length;\n };\n\n _proto.unshift = function unshift(v) {\n var entry = {\n data: v,\n next: this.head\n };\n if (this.length === 0) this.tail = entry;\n this.head = entry;\n ++this.length;\n };\n\n _proto.shift = function shift() {\n if (this.length === 0) return;\n var ret = this.head.data;\n if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n --this.length;\n return ret;\n };\n\n _proto.clear = function clear() {\n this.head = this.tail = null;\n this.length = 0;\n };\n\n _proto.join = function join(s) {\n if (this.length === 0) return '';\n var p = this.head;\n var ret = '' + p.data;\n\n while (p = p.next) {\n ret += s + p.data;\n }\n\n return ret;\n };\n\n _proto.concat = function concat(n) {\n if (this.length === 0) return Buffer.alloc(0);\n var ret = Buffer.allocUnsafe(n >>> 0);\n var p = this.head;\n var i = 0;\n\n while (p) {\n copyBuffer(p.data, ret, i);\n i += p.data.length;\n p = p.next;\n }\n\n return ret;\n } // Consumes a specified amount of bytes or characters from the buffered data.\n ;\n\n _proto.consume = function consume(n, hasStrings) {\n var ret;\n\n if (n < this.head.data.length) {\n // `slice` is the same for buffers and strings.\n ret = this.head.data.slice(0, n);\n this.head.data = this.head.data.slice(n);\n } else if (n === this.head.data.length) {\n // First chunk is a perfect match.\n ret = this.shift();\n } else {\n // Result spans more than one buffer.\n ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n }\n\n return ret;\n };\n\n _proto.first = function first() {\n return this.head.data;\n } // Consumes a specified amount of characters from the buffered data.\n ;\n\n _proto._getString = function _getString(n) {\n var p = this.head;\n var c = 1;\n var ret = p.data;\n n -= ret.length;\n\n while (p = p.next) {\n var str = p.data;\n var nb = n > str.length ? str.length : n;\n if (nb === str.length) ret += str;else ret += str.slice(0, n);\n n -= nb;\n\n if (n === 0) {\n if (nb === str.length) {\n ++c;\n if (p.next) this.head = p.next;else this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = str.slice(nb);\n }\n\n break;\n }\n\n ++c;\n }\n\n this.length -= c;\n return ret;\n } // Consumes a specified amount of bytes from the buffered data.\n ;\n\n _proto._getBuffer = function _getBuffer(n) {\n var ret = Buffer.allocUnsafe(n);\n var p = this.head;\n var c = 1;\n p.data.copy(ret);\n n -= p.data.length;\n\n while (p = p.next) {\n var buf = p.data;\n var nb = n > buf.length ? buf.length : n;\n buf.copy(ret, ret.length - n, 0, nb);\n n -= nb;\n\n if (n === 0) {\n if (nb === buf.length) {\n ++c;\n if (p.next) this.head = p.next;else this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = buf.slice(nb);\n }\n\n break;\n }\n\n ++c;\n }\n\n this.length -= c;\n return ret;\n } // Make sure the linked list only shows the minimal necessary information.\n ;\n\n _proto[custom] = function (_, options) {\n return inspect(this, _objectSpread({}, options, {\n // Only inspect one level.\n depth: 0,\n // It should not recurse.\n customInspect: false\n }));\n };\n\n return BufferList;\n}();","'use strict'\n\nvar experimentalWarnings = new Set();\n\nfunction emitExperimentalWarning(feature) {\n if (experimentalWarnings.has(feature)) return;\n var msg = feature + ' is an experimental feature. This feature could ' +\n 'change at any time';\n experimentalWarnings.add(feature);\n process.emitWarning(msg, 'ExperimentalWarning');\n}\n\nfunction noop() {}\n\nmodule.exports.emitExperimentalWarning = process.emitWarning\n ? emitExperimentalWarning\n : noop;\n","'use strict';\n\nvar _Object$setPrototypeO;\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar finished = require('./end-of-stream');\n\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\n\nfunction createIterResult(value, done) {\n return {\n value: value,\n done: done\n };\n}\n\nfunction readAndResolve(iter) {\n var resolve = iter[kLastResolve];\n\n if (resolve !== null) {\n var data = iter[kStream].read(); // we defer if data is null\n // we can be expecting either 'end' or\n // 'error'\n\n if (data !== null) {\n iter[kLastPromise] = null;\n iter[kLastResolve] = null;\n iter[kLastReject] = null;\n resolve(createIterResult(data, false));\n }\n }\n}\n\nfunction onReadable(iter) {\n // we wait for the next tick, because it might\n // emit an error with process.nextTick\n process.nextTick(readAndResolve, iter);\n}\n\nfunction wrapForNext(lastPromise, iter) {\n return function (resolve, reject) {\n lastPromise.then(function () {\n if (iter[kEnded]) {\n resolve(createIterResult(undefined, true));\n return;\n }\n\n iter[kHandlePromise](resolve, reject);\n }, reject);\n };\n}\n\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n get stream() {\n return this[kStream];\n },\n\n next: function next() {\n var _this = this;\n\n // if we have detected an error in the meanwhile\n // reject straight away\n var error = this[kError];\n\n if (error !== null) {\n return Promise.reject(error);\n }\n\n if (this[kEnded]) {\n return Promise.resolve(createIterResult(undefined, true));\n }\n\n if (this[kStream].destroyed) {\n // We need to defer via nextTick because if .destroy(err) is\n // called, the error will be emitted via nextTick, and\n // we cannot guarantee that there is no error lingering around\n // waiting to be emitted.\n return new Promise(function (resolve, reject) {\n process.nextTick(function () {\n if (_this[kError]) {\n reject(_this[kError]);\n } else {\n resolve(createIterResult(undefined, true));\n }\n });\n });\n } // if we have multiple next() calls\n // we will wait for the previous Promise to finish\n // this logic is optimized to support for await loops,\n // where next() is only called once at a time\n\n\n var lastPromise = this[kLastPromise];\n var promise;\n\n if (lastPromise) {\n promise = new Promise(wrapForNext(lastPromise, this));\n } else {\n // fast path needed to support multiple this.push()\n // without triggering the next() queue\n var data = this[kStream].read();\n\n if (data !== null) {\n return Promise.resolve(createIterResult(data, false));\n }\n\n promise = new Promise(this[kHandlePromise]);\n }\n\n this[kLastPromise] = promise;\n return promise;\n }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n var _this2 = this;\n\n // destroy(err, cb) is a private API\n // we can guarantee we have that here, because we control the\n // Readable class this is attached to\n return new Promise(function (resolve, reject) {\n _this2[kStream].destroy(null, function (err) {\n if (err) {\n reject(err);\n return;\n }\n\n resolve(createIterResult(undefined, true));\n });\n });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\n\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n var _Object$create;\n\n var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n value: stream,\n writable: true\n }), _defineProperty(_Object$create, kLastResolve, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kLastReject, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kError, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kEnded, {\n value: stream._readableState.endEmitted,\n writable: true\n }), _defineProperty(_Object$create, kHandlePromise, {\n value: function value(resolve, reject) {\n var data = iterator[kStream].read();\n\n if (data) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(data, false));\n } else {\n iterator[kLastResolve] = resolve;\n iterator[kLastReject] = reject;\n }\n },\n writable: true\n }), _Object$create));\n iterator[kLastPromise] = null;\n finished(stream, function (err) {\n if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise\n // returned by next() and store the error\n\n if (reject !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n reject(err);\n }\n\n iterator[kError] = err;\n return;\n }\n\n var resolve = iterator[kLastResolve];\n\n if (resolve !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(undefined, true));\n }\n\n iterator[kEnded] = true;\n });\n stream.on('readable', onReadable.bind(null, iterator));\n return iterator;\n};\n\nmodule.exports = createReadableStreamAsyncIterator;","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\nrequire('inherits')(PassThrough, Transform);\n\nfunction PassThrough(options) {\n if (!(this instanceof PassThrough)) return new PassThrough(options);\n Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n cb(null, chunk);\n};","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar eos;\n\nfunction once(callback) {\n var called = false;\n return function () {\n if (called) return;\n called = true;\n callback.apply(void 0, arguments);\n };\n}\n\nvar _require$codes = require('../../../errors').codes,\n ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\n\nfunction noop(err) {\n // Rethrow the error if it exists to avoid swallowing it\n if (err) throw err;\n}\n\nfunction isRequest(stream) {\n return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction destroyer(stream, reading, writing, callback) {\n callback = once(callback);\n var closed = false;\n stream.on('close', function () {\n closed = true;\n });\n if (eos === undefined) eos = require('./end-of-stream');\n eos(stream, {\n readable: reading,\n writable: writing\n }, function (err) {\n if (err) return callback(err);\n closed = true;\n callback();\n });\n var destroyed = false;\n return function (err) {\n if (closed) return;\n if (destroyed) return;\n destroyed = true; // request.destroy just do .end - .abort is what we want\n\n if (isRequest(stream)) return stream.abort();\n if (typeof stream.destroy === 'function') return stream.destroy();\n callback(err || new ERR_STREAM_DESTROYED('pipe'));\n };\n}\n\nfunction call(fn) {\n fn();\n}\n\nfunction pipe(from, to) {\n return from.pipe(to);\n}\n\nfunction popCallback(streams) {\n if (!streams.length) return noop;\n if (typeof streams[streams.length - 1] !== 'function') return noop;\n return streams.pop();\n}\n\nfunction pipeline() {\n for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n streams[_key] = arguments[_key];\n }\n\n var callback = popCallback(streams);\n if (Array.isArray(streams[0])) streams = streams[0];\n\n if (streams.length < 2) {\n throw new ERR_MISSING_ARGS('streams');\n }\n\n var error;\n var destroys = streams.map(function (stream, i) {\n var reading = i < streams.length - 1;\n var writing = i > 0;\n return destroyer(stream, reading, writing, function (err) {\n if (!error) error = err;\n if (err) destroys.forEach(call);\n if (reading) return;\n destroys.forEach(call);\n callback(error);\n });\n });\n return streams.reduce(pipe);\n}\n\nmodule.exports = pipeline;","// function to determine filetype from a chunk\n'use strict'\n\nvar determine = function(chunk, start, LIMIT) {\n var limit = Math.min(LIMIT - start, chunk.length)\n var current = []\n var filetype = null\n var index = -1\n\n while (!filetype && ++index < limit) {\n var c = chunk[index]\n if (c === '\\n') {\n if (current.length + index) {\n filetype = 'drill'\n current = []\n }\n } else {\n current.push(c)\n if (c === '*' && current[0] !== ';') {\n filetype = 'gerber'\n current = []\n }\n }\n }\n\n return filetype\n}\n\nmodule.exports = determine\n","// function for getting the next block of the chunk\n// returns {next: '_', read: [chars read], lines: [lines read]}\n'use strict'\n\nvar getNext = function(type, chunk, start) {\n if (type !== 'gerber' && type !== 'drill') {\n throw new Error('filetype to get next block must be \"drill\" or \"gerber\"')\n }\n\n // parsing constants\n var limit = chunk.length - start\n var split = type === 'gerber' ? '*' : '\\n'\n var param = type === 'gerber' ? '%' : ''\n\n // search flags\n var splitFound = false\n var paramStarted = false\n var paramFound = false\n var blockFound = false\n\n // chunk results\n var found = []\n var read = 0\n var lines = 0\n\n while (!blockFound && read < limit) {\n var c = chunk[start + read]\n\n // count newlines\n if (c === '\\n') {\n lines++\n }\n\n // check for a param start or end\n if (c === param) {\n if (!paramStarted) {\n paramStarted = true\n found.push(c)\n } else {\n paramFound = true\n found.pop()\n }\n } else if (c === split) {\n splitFound = true\n if (paramStarted) {\n found.push(c)\n }\n } else if (c >= ' ' && c <= '~') {\n found.push(c)\n }\n\n read++\n blockFound = splitFound && (!paramStarted || paramFound)\n }\n\n var block = blockFound ? found.join('').trim() : ''\n var rem = !blockFound ? found.join('') : ''\n return {lines: lines, read: read, block: block, rem: rem}\n}\n\nmodule.exports = getNext\n","// parse gerber function\n// takes a parser transform stream and a block string\n'use strict'\n\nvar commands = require('./_commands')\nvar normalize = require('./normalize-coord')\nvar parseCoord = require('./parse-coord')\nvar parseMacroBlock = require('./_parse-macro-block')\n\n// g-code set matchers\nvar RE_MODE = /^G0*([123])/\nvar RE_REGION = /^G3([67])/\nvar RE_ARC = /^G7([45])/\nvar RE_BKP_UNITS = /^G7([01])/\nvar RE_BKP_NOTA = /^G9([01])/\nvar RE_COMMENT = /^G0*4/\n\n// tool changes\nvar RE_TOOL = /^(?:G54)?D0*([1-9]\\d+)/\n\n// operations\nvar RE_OP = /D0*([123])$/\nvar RE_COORD = /^(?:G0*[123])?((?:[XYIJ][+-]?\\d+){1,4})(?:D0*[123])?$/\n\n// parameter code matchers\nvar RE_UNITS = /^%MO(IN|MM)/\n// format spec regexp courtesy @summivox\nvar RE_FORMAT = /^%FS([LT]?)([AI]?)(.*)X([0-7])([0-7])Y\\4\\5/\nvar RE_POLARITY = /^%LP([CD])/\nvar RE_STEP_REP = /^%SR(?:X(\\d+)Y(\\d+)I([\\d.]+)J([\\d.]+))?/\nvar RE_TOOL_DEF = /^%ADD0*(\\d{2,})([A-Za-z_$][\\w\\-.]*)(?:,((?:X?[\\d.]+)*))?/\nvar RE_MACRO = /^%AM([A-Za-z_$][\\w\\-.]*)\\*?(.*)/\n\nvar parseToolDef = function(parser, block) {\n var format = {places: parser.format.places}\n var toolMatch = block.match(RE_TOOL_DEF)\n var tool = toolMatch[1]\n var shapeMatch = toolMatch[2]\n var toolArgs = toolMatch[3] ? toolMatch[3].split('X') : []\n\n // get the shape\n var shape\n var maxArgs\n if (shapeMatch === 'C') {\n shape = 'circle'\n maxArgs = 3\n } else if (shapeMatch === 'R') {\n shape = 'rect'\n maxArgs = 4\n } else if (shapeMatch === 'O') {\n shape = 'obround'\n maxArgs = 4\n } else if (shapeMatch === 'P') {\n shape = 'poly'\n maxArgs = 5\n } else {\n shape = shapeMatch\n maxArgs = 0\n }\n\n var val\n if (shape === 'circle') {\n val = [normalize(toolArgs[0], format)]\n } else if (shape === 'rect' || shape === 'obround') {\n val = [normalize(toolArgs[0], format), normalize(toolArgs[1], format)]\n } else if (shape === 'poly') {\n val = [normalize(toolArgs[0], format), Number(toolArgs[1]), 0]\n if (toolArgs[2]) {\n val[2] = Number(toolArgs[2])\n }\n } else {\n val = toolArgs.map(Number)\n }\n\n var hole = []\n if (toolArgs[maxArgs - 1]) {\n hole = [\n normalize(toolArgs[maxArgs - 2], format),\n normalize(toolArgs[maxArgs - 1], format),\n ]\n } else if (toolArgs[maxArgs - 2]) {\n hole = [normalize(toolArgs[maxArgs - 2], format)]\n }\n var toolDef = {shape: shape, params: val, hole: hole}\n return parser._push(commands.tool(tool, toolDef))\n}\n\nvar parseMacroDef = function(parser, block) {\n var macroMatch = block.match(RE_MACRO)\n var name = macroMatch[1]\n if (name.match(/-/)) {\n parser._warn('hyphens in macro name are illegal: ' + name)\n }\n var blockMatch = macroMatch[2].length ? macroMatch[2].split('*') : []\n var blocks = blockMatch.filter(Boolean).map(function(block) {\n return parseMacroBlock(parser, block)\n })\n\n return parser._push(commands.macro(name, blocks))\n}\n\nvar parse = function(parser, block) {\n if (RE_COMMENT.test(block)) {\n return\n }\n\n if (block === 'M02') {\n return parser._push(commands.done())\n }\n\n if (RE_REGION.test(block)) {\n var regionMatch = block.match(RE_REGION)[1]\n var region = regionMatch === '6'\n return parser._push(commands.set('region', region))\n }\n\n if (RE_ARC.test(block)) {\n var arcMatch = block.match(RE_ARC)[1]\n var arc = arcMatch === '4' ? 's' : 'm'\n return parser._push(commands.set('arc', arc))\n }\n\n if (RE_UNITS.test(block)) {\n var unitsMatch = block.match(RE_UNITS)[1]\n var units = unitsMatch === 'IN' ? 'in' : 'mm'\n return parser._push(commands.set('units', units))\n }\n\n if (RE_BKP_UNITS.test(block)) {\n var bkpUnitsMatch = block.match(RE_BKP_UNITS)[1]\n var backupUnits = bkpUnitsMatch === '0' ? 'in' : 'mm'\n return parser._push(commands.set('backupUnits', backupUnits))\n }\n\n if (RE_FORMAT.test(block)) {\n var formatMatch = block.match(RE_FORMAT)\n var zero = formatMatch[1]\n var nota = formatMatch[2]\n var unknown = formatMatch[3]\n var leading = Number(formatMatch[4])\n var trailing = Number(formatMatch[5])\n var format = parser.format\n\n format.zero = format.zero || zero\n if (!format.places) {\n format.places = [leading, trailing]\n }\n\n // warn if zero suppression missing or set to trailing\n if (!format.zero) {\n format.zero = 'L'\n parser._warn('zero suppression missing from format; assuming leading')\n } else if (format.zero === 'T') {\n parser._warn('trailing zero suppression has been deprecated')\n }\n\n // warn if there were unknown characters in the format spec\n if (unknown) {\n parser._warn(\n 'unknown characters \"' + unknown + '\" in \"' + block + '\" were ignored'\n )\n }\n\n var epsilon = 1.5 * Math.pow(10, -format.places[1])\n parser._push(commands.set('nota', nota))\n parser._push(commands.set('epsilon', epsilon))\n return\n }\n\n if (RE_BKP_NOTA.test(block)) {\n var bkpNotaMatch = block.match(RE_BKP_NOTA)[1]\n var backupNota = bkpNotaMatch === '0' ? 'A' : 'I'\n return parser._push(commands.set('backupNota', backupNota))\n }\n\n if (RE_POLARITY.test(block)) {\n var polarity = block.match(RE_POLARITY)[1]\n return parser._push(commands.level('polarity', polarity))\n }\n\n if (RE_STEP_REP.test(block)) {\n var stepRepeatMatch = block.match(RE_STEP_REP)\n var x = stepRepeatMatch[1] || 1\n var y = stepRepeatMatch[2] || 1\n var i = stepRepeatMatch[3] || 0\n var j = stepRepeatMatch[4] || 0\n var sr = {x: Number(x), y: Number(y), i: Number(i), j: Number(j)}\n return parser._push(commands.level('stepRep', sr))\n }\n\n if (RE_TOOL.test(block)) {\n var tool = block.match(RE_TOOL)[1]\n return parser._push(commands.set('tool', tool))\n }\n\n if (RE_TOOL_DEF.test(block)) {\n return parseToolDef(parser, block)\n }\n\n if (RE_MACRO.test(block)) {\n return parseMacroDef(parser, block)\n }\n\n // finally, look for mode commands and operations\n // they may appear in the same block\n if (RE_OP.test(block) || RE_MODE.test(block) || RE_COORD.test(block)) {\n var opMatch = block.match(RE_OP)\n var modeMatch = block.match(RE_MODE)\n var coordMatch = block.match(RE_COORD)\n var mode\n\n if (modeMatch) {\n if (modeMatch[1] === '1') {\n mode = 'i'\n } else if (modeMatch[1] === '2') {\n mode = 'cw'\n } else {\n mode = 'ccw'\n }\n\n parser._push(commands.set('mode', mode))\n }\n\n if (opMatch || coordMatch) {\n var opCode = opMatch ? opMatch[1] : ''\n var coordString = coordMatch ? coordMatch[1] : ''\n var coord = parseCoord.parse(coordString, parser.format)\n\n var op = 'last'\n if (opCode === '1') {\n op = 'int'\n } else if (opCode === '2') {\n op = 'move'\n } else if (opCode === '3') {\n op = 'flash'\n }\n\n parser._push(commands.op(op, coord))\n }\n\n return\n }\n\n // if we reach here the block was unhandled, so warn if it is not empty\n return parser._warn(\n 'block \"' + block + '\" was not recognized and was ignored'\n )\n}\n\nmodule.exports = parse\n","/**\n * lodash (Custom Build) \n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors \n * Released under MIT license \n * Based on Underscore.js 1.8.3 \n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n MAX_SAFE_INTEGER = 9007199254740991,\n MAX_INTEGER = 1.7976931348623157e+308,\n NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Used to compose unicode character classes. */\nvar rsAstralRange = '\\\\ud800-\\\\udfff',\n rsComboMarksRange = '\\\\u0300-\\\\u036f\\\\ufe20-\\\\ufe23',\n rsComboSymbolsRange = '\\\\u20d0-\\\\u20f0',\n rsVarRange = '\\\\ufe0e\\\\ufe0f';\n\n/** Used to compose unicode capture groups. */\nvar rsAstral = '[' + rsAstralRange + ']',\n rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',\n rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n rsNonAstral = '[^' + rsAstralRange + ']',\n rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n rsZWJ = '\\\\u200d';\n\n/** Used to compose unicode regexes. */\nvar reOptMod = rsModifier + '?',\n rsOptVar = '[' + rsVarRange + ']?',\n rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n rsSeq = rsOptVar + reOptMod + rsOptJoin,\n rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\nvar reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */\nvar reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/**\n * Gets the size of an ASCII `string`.\n *\n * @private\n * @param {string} string The string inspect.\n * @returns {number} Returns the string size.\n */\nvar asciiSize = baseProperty('length');\n\n/**\n * Converts an ASCII `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction asciiToArray(string) {\n return string.split('');\n}\n\n/**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction baseProperty(key) {\n return function(object) {\n return object == null ? undefined : object[key];\n };\n}\n\n/**\n * Checks if `string` contains Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n */\nfunction hasUnicode(string) {\n return reHasUnicode.test(string);\n}\n\n/**\n * Gets the number of symbols in `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the string size.\n */\nfunction stringSize(string) {\n return hasUnicode(string)\n ? unicodeSize(string)\n : asciiSize(string);\n}\n\n/**\n * Converts `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction stringToArray(string) {\n return hasUnicode(string)\n ? unicodeToArray(string)\n : asciiToArray(string);\n}\n\n/**\n * Gets the size of a Unicode `string`.\n *\n * @private\n * @param {string} string The string inspect.\n * @returns {number} Returns the string size.\n */\nfunction unicodeSize(string) {\n var result = reUnicode.lastIndex = 0;\n while (reUnicode.test(string)) {\n result++;\n }\n return result;\n}\n\n/**\n * Converts a Unicode `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction unicodeToArray(string) {\n return string.match(reUnicode) || [];\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeCeil = Math.ceil,\n nativeFloor = Math.floor;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.repeat` which doesn't coerce arguments.\n *\n * @private\n * @param {string} string The string to repeat.\n * @param {number} n The number of times to repeat the string.\n * @returns {string} Returns the repeated string.\n */\nfunction baseRepeat(string, n) {\n var result = '';\n if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n return result;\n }\n // Leverage the exponentiation by squaring algorithm for a faster repeat.\n // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n do {\n if (n % 2) {\n result += string;\n }\n n = nativeFloor(n / 2);\n if (n) {\n string += string;\n }\n } while (n);\n\n return result;\n}\n\n/**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\nfunction baseSlice(array, start, end) {\n var index = -1,\n length = array.length;\n\n if (start < 0) {\n start = -start > length ? 0 : (length + start);\n }\n end = end > length ? length : end;\n if (end < 0) {\n end += length;\n }\n length = start > end ? 0 : ((end - start) >>> 0);\n start >>>= 0;\n\n var result = Array(length);\n while (++index < length) {\n result[index] = array[index + start];\n }\n return result;\n}\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n // Exit early for strings to avoid a performance hit in some environments.\n if (typeof value == 'string') {\n return value;\n }\n if (isSymbol(value)) {\n return symbolToString ? symbolToString.call(value) : '';\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\n/**\n * Casts `array` to a slice if it's needed.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {number} start The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the cast slice.\n */\nfunction castSlice(array, start, end) {\n var length = array.length;\n end = end === undefined ? length : end;\n return (!start && end >= length) ? array : baseSlice(array, start, end);\n}\n\n/**\n * Creates the padding for `string` based on `length`. The `chars` string\n * is truncated if the number of characters exceeds `length`.\n *\n * @private\n * @param {number} length The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padding for `string`.\n */\nfunction createPadding(length, chars) {\n chars = chars === undefined ? ' ' : baseToString(chars);\n\n var charsLength = chars.length;\n if (charsLength < 2) {\n return charsLength ? baseRepeat(chars, length) : chars;\n }\n var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));\n return hasUnicode(chars)\n ? castSlice(stringToArray(result), 0, length).join('')\n : result.slice(0, length);\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n if (!value) {\n return value === 0 ? value : 0;\n }\n value = toNumber(value);\n if (value === INFINITY || value === -INFINITY) {\n var sign = (value < 0 ? -1 : 1);\n return sign * MAX_INTEGER;\n }\n return value === value ? value : 0;\n}\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n var result = toFinite(value),\n remainder = result % 1;\n\n return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n if (isObject(value)) {\n var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n value = isObject(other) ? (other + '') : other;\n }\n if (typeof value != 'string') {\n return value === 0 ? value : +value;\n }\n value = value.replace(reTrim, '');\n var isBinary = reIsBinary.test(value);\n return (isBinary || reIsOctal.test(value))\n ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n : (reIsBadHex.test(value) ? NAN : +value);\n}\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n return value == null ? '' : baseToString(value);\n}\n\n/**\n * Pads `string` on the left side if it's shorter than `length`. Padding\n * characters are truncated if they exceed `length`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to pad.\n * @param {number} [length=0] The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padded string.\n * @example\n *\n * _.padStart('abc', 6);\n * // => ' abc'\n *\n * _.padStart('abc', 6, '_-');\n * // => '_-_abc'\n *\n * _.padStart('abc', 3);\n * // => 'abc'\n */\nfunction padStart(string, length, chars) {\n string = toString(string);\n length = toInteger(length);\n\n var strLength = length ? stringSize(string) : 0;\n return (length && strLength < length)\n ? (createPadding(length - strLength, chars) + string)\n : string;\n}\n\nmodule.exports = padStart;\n","/**\n * lodash (Custom Build) \n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors \n * Released under MIT license \n * Based on Underscore.js 1.8.3 \n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n MAX_SAFE_INTEGER = 9007199254740991,\n MAX_INTEGER = 1.7976931348623157e+308,\n NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Used to compose unicode character classes. */\nvar rsAstralRange = '\\\\ud800-\\\\udfff',\n rsComboMarksRange = '\\\\u0300-\\\\u036f\\\\ufe20-\\\\ufe23',\n rsComboSymbolsRange = '\\\\u20d0-\\\\u20f0',\n rsVarRange = '\\\\ufe0e\\\\ufe0f';\n\n/** Used to compose unicode capture groups. */\nvar rsAstral = '[' + rsAstralRange + ']',\n rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',\n rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n rsNonAstral = '[^' + rsAstralRange + ']',\n rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n rsZWJ = '\\\\u200d';\n\n/** Used to compose unicode regexes. */\nvar reOptMod = rsModifier + '?',\n rsOptVar = '[' + rsVarRange + ']?',\n rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n rsSeq = rsOptVar + reOptMod + rsOptJoin,\n rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\nvar reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */\nvar reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/**\n * Gets the size of an ASCII `string`.\n *\n * @private\n * @param {string} string The string inspect.\n * @returns {number} Returns the string size.\n */\nvar asciiSize = baseProperty('length');\n\n/**\n * Converts an ASCII `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction asciiToArray(string) {\n return string.split('');\n}\n\n/**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction baseProperty(key) {\n return function(object) {\n return object == null ? undefined : object[key];\n };\n}\n\n/**\n * Checks if `string` contains Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n */\nfunction hasUnicode(string) {\n return reHasUnicode.test(string);\n}\n\n/**\n * Gets the number of symbols in `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the string size.\n */\nfunction stringSize(string) {\n return hasUnicode(string)\n ? unicodeSize(string)\n : asciiSize(string);\n}\n\n/**\n * Converts `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction stringToArray(string) {\n return hasUnicode(string)\n ? unicodeToArray(string)\n : asciiToArray(string);\n}\n\n/**\n * Gets the size of a Unicode `string`.\n *\n * @private\n * @param {string} string The string inspect.\n * @returns {number} Returns the string size.\n */\nfunction unicodeSize(string) {\n var result = reUnicode.lastIndex = 0;\n while (reUnicode.test(string)) {\n result++;\n }\n return result;\n}\n\n/**\n * Converts a Unicode `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction unicodeToArray(string) {\n return string.match(reUnicode) || [];\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeCeil = Math.ceil,\n nativeFloor = Math.floor;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.repeat` which doesn't coerce arguments.\n *\n * @private\n * @param {string} string The string to repeat.\n * @param {number} n The number of times to repeat the string.\n * @returns {string} Returns the repeated string.\n */\nfunction baseRepeat(string, n) {\n var result = '';\n if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n return result;\n }\n // Leverage the exponentiation by squaring algorithm for a faster repeat.\n // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n do {\n if (n % 2) {\n result += string;\n }\n n = nativeFloor(n / 2);\n if (n) {\n string += string;\n }\n } while (n);\n\n return result;\n}\n\n/**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\nfunction baseSlice(array, start, end) {\n var index = -1,\n length = array.length;\n\n if (start < 0) {\n start = -start > length ? 0 : (length + start);\n }\n end = end > length ? length : end;\n if (end < 0) {\n end += length;\n }\n length = start > end ? 0 : ((end - start) >>> 0);\n start >>>= 0;\n\n var result = Array(length);\n while (++index < length) {\n result[index] = array[index + start];\n }\n return result;\n}\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n // Exit early for strings to avoid a performance hit in some environments.\n if (typeof value == 'string') {\n return value;\n }\n if (isSymbol(value)) {\n return symbolToString ? symbolToString.call(value) : '';\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\n/**\n * Casts `array` to a slice if it's needed.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {number} start The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the cast slice.\n */\nfunction castSlice(array, start, end) {\n var length = array.length;\n end = end === undefined ? length : end;\n return (!start && end >= length) ? array : baseSlice(array, start, end);\n}\n\n/**\n * Creates the padding for `string` based on `length`. The `chars` string\n * is truncated if the number of characters exceeds `length`.\n *\n * @private\n * @param {number} length The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padding for `string`.\n */\nfunction createPadding(length, chars) {\n chars = chars === undefined ? ' ' : baseToString(chars);\n\n var charsLength = chars.length;\n if (charsLength < 2) {\n return charsLength ? baseRepeat(chars, length) : chars;\n }\n var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));\n return hasUnicode(chars)\n ? castSlice(stringToArray(result), 0, length).join('')\n : result.slice(0, length);\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n if (!value) {\n return value === 0 ? value : 0;\n }\n value = toNumber(value);\n if (value === INFINITY || value === -INFINITY) {\n var sign = (value < 0 ? -1 : 1);\n return sign * MAX_INTEGER;\n }\n return value === value ? value : 0;\n}\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n var result = toFinite(value),\n remainder = result % 1;\n\n return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n if (isObject(value)) {\n var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n value = isObject(other) ? (other + '') : other;\n }\n if (typeof value != 'string') {\n return value === 0 ? value : +value;\n }\n value = value.replace(reTrim, '');\n var isBinary = reIsBinary.test(value);\n return (isBinary || reIsOctal.test(value))\n ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n : (reIsBadHex.test(value) ? NAN : +value);\n}\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n return value == null ? '' : baseToString(value);\n}\n\n/**\n * Pads `string` on the right side if it's shorter than `length`. Padding\n * characters are truncated if they exceed `length`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to pad.\n * @param {number} [length=0] The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padded string.\n * @example\n *\n * _.padEnd('abc', 6);\n * // => 'abc '\n *\n * _.padEnd('abc', 6, '_-');\n * // => 'abc_-_'\n *\n * _.padEnd('abc', 3);\n * // => 'abc'\n */\nfunction padEnd(string, length, chars) {\n string = toString(string);\n length = toInteger(length);\n\n var strLength = length ? stringSize(string) : 0;\n return (length && strLength < length)\n ? (string + createPadding(length - strLength, chars))\n : string;\n}\n\nmodule.exports = padEnd;\n","// function to parse a macro block into a primitive object\n'use strict'\n\nvar parseMacroExpr = require('./_parse-macro-expression')\n\nvar RE_NUM = /^-?[\\d.]+$/\nvar RE_VAR_DEF = /^(\\$[\\d+])=(.+)/\n\nvar parseMacroBlock = function(parser, block) {\n // check first for a comment\n if (block[0] === '0') {\n return {type: 'comment'}\n }\n\n // variable definition\n if (RE_VAR_DEF.test(block)) {\n var varDefMatch = block.match(RE_VAR_DEF)\n var varName = varDefMatch[1]\n var varExpr = varDefMatch[2]\n var evaluate = parseMacroExpr(parser, varExpr)\n\n var setMods = function(mods) {\n mods[varName] = evaluate(mods)\n\n return mods\n }\n return {type: 'variable', set: setMods}\n }\n\n // map a primitive param to a number or, if an expression, a function\n var modVal = function(m) {\n if (RE_NUM.test(m)) {\n return Number(m)\n }\n return parseMacroExpr(parser, m)\n }\n\n var mods = block.split(',').map(modVal)\n var code = mods[0]\n var exp = mods[1]\n\n // circle primitive\n if (code === 1) {\n return {\n type: 'circle',\n exp: exp,\n dia: mods[2],\n cx: mods[3],\n cy: mods[4],\n // handle optional rotation with circle primitives\n rot: mods[5] || 0,\n }\n }\n\n // vector primitive\n if (code === 2) {\n parser._warn('macro aperture vector primitives with code 2 are deprecated')\n }\n\n if (code === 2 || code === 20) {\n return {\n type: 'vect',\n exp: exp,\n width: mods[2],\n x1: mods[3],\n y1: mods[4],\n x2: mods[5],\n y2: mods[6],\n rot: mods[7],\n }\n }\n\n // center rectangle\n if (code === 21) {\n return {\n type: 'rect',\n exp: exp,\n width: mods[2],\n height: mods[3],\n cx: mods[4],\n cy: mods[5],\n rot: mods[6],\n }\n }\n\n if (code === 22) {\n parser._warn(\n 'macro aperture lower-left rectangle primitives are deprecated'\n )\n return {\n type: 'rectLL',\n exp: exp,\n width: mods[2],\n height: mods[3],\n x: mods[4],\n y: mods[5],\n rot: mods[6],\n }\n }\n\n if (code === 4) {\n return {\n type: 'outline',\n exp: exp,\n points: mods.slice(3, -1).map(Number),\n rot: Number(mods[mods.length - 1]),\n }\n }\n\n if (code === 5) {\n return {\n type: 'poly',\n exp: exp,\n vertices: mods[2],\n cx: mods[3],\n cy: mods[4],\n dia: mods[5],\n rot: mods[6],\n }\n }\n\n if (code === 6) {\n // moire primitive always has exposure on\n return {\n type: 'moire',\n exp: 1,\n cx: mods[1],\n cy: mods[2],\n dia: mods[3],\n ringThx: mods[4],\n ringGap: mods[5],\n maxRings: mods[6],\n crossThx: mods[7],\n crossLen: mods[8],\n rot: mods[9],\n }\n }\n\n if (code === 7) {\n // thermal primitive always had exposure on\n return {\n type: 'thermal',\n exp: 1,\n cx: mods[1],\n cy: mods[2],\n outerDia: mods[3],\n innerDia: mods[4],\n gap: mods[5],\n rot: mods[6],\n }\n } else {\n parser._warn(code + ' is an unrecognized primitive for a macro aperture')\n }\n}\n\nmodule.exports = parseMacroBlock\n","// parse a macro expression and return a function that takes mods\n'use strict'\n\nvar RE_OP = /[+\\-/xX()]/\nvar RE_NUMBER = /[$\\d.]+/\nvar RE_TOKEN = new RegExp([RE_OP.source, RE_NUMBER.source].join('|'), 'g')\n\nmodule.exports = function parseMacroExpression(parser, expr) {\n // tokenize the expression\n var tokens = expr.match(RE_TOKEN)\n\n // forward declare parse expression\n var parseExpression\n\n // primary tokens are numbers and parentheses\n var parsePrimary = function() {\n var t = tokens.shift()\n var exp\n\n if (RE_NUMBER.test(t)) {\n exp = {type: 'n', val: t}\n } else {\n exp = parseExpression()\n tokens.shift()\n }\n return exp\n }\n\n // parse multiplication and division tokens\n var parseMultiplication = function() {\n var exp = parsePrimary()\n var t = tokens[0]\n\n if (t === 'X') {\n parser._warn(\"multiplication in macros should use 'x', not 'X'\")\n t = 'x'\n }\n while (t === 'x' || t === '/') {\n tokens.shift()\n var right = parsePrimary()\n exp = {type: t, left: exp, right: right}\n t = tokens[0]\n }\n return exp\n }\n\n // parse addition and subtraction tokens\n parseExpression = function() {\n var exp = parseMultiplication()\n var t = tokens[0]\n while (t === '+' || t === '-') {\n tokens.shift()\n var right = parseMultiplication()\n exp = {type: t, left: exp, right: right}\n t = tokens[0]\n }\n return exp\n }\n\n // parse the expression string into a binary tree\n var tree = parseExpression()\n\n // evalute by recursively traversing the tree\n var evaluate = function(op, mods) {\n var getValue = function(t) {\n if (t[0] === '$') {\n return Number(mods[t])\n }\n return Number(t)\n }\n\n var type = op.type\n if (type === 'n') {\n return getValue(op.val)\n }\n if (type === '+') {\n return evaluate(op.left, mods) + evaluate(op.right, mods)\n }\n if (type === '-') {\n return evaluate(op.left, mods) - evaluate(op.right, mods)\n }\n if (type === 'x') {\n return evaluate(op.left, mods) * evaluate(op.right, mods)\n }\n // else division\n return evaluate(op.left, mods) / evaluate(op.right, mods)\n }\n\n // return the evaluation function bound to the parsed expression tree\n return function(mods) {\n return evaluate(tree, mods)\n }\n}\n","// parse drill function\n// takes a parser transform stream and a block string\n'use strict'\n\nvar numIsFinite = require('lodash.isfinite')\n\nvar commands = require('./_commands')\nvar drillMode = require('./_drill-mode')\nvar normalize = require('./normalize-coord')\nvar parseCoord = require('./parse-coord')\n\nvar RE_ALTIUM_HINT = /;FILE_FORMAT=(\\d):(\\d)/\nvar RE_ALTIUM_PLATING_HINT = /;TYPE=(PLATED|NON_PLATED)/\nvar RE_KI_HINT = /;FORMAT={(.):(.)\\/ (absolute|.+)? \\/ (metric|inch) \\/.+(trailing|leading|decimal|keep)/\n\nvar RE_UNITS = /^(INCH|METRIC|M71|M72)/\nvar RE_ZERO = /,([TL])Z/\nvar RE_FORMAT = /,(0{1,8})\\.(0{1,8})/\nvar RE_TOOL_DEF = /T0*(\\d+)[\\S]*C([\\d.]+)/\nvar RE_TOOL_SET = /T0*(\\d+)(?![\\S]*C)/\nvar RE_COORD = /((?:[XYIJA][+-]?[\\d.]+){1,4})(?:G85((?:[XY][+-]?[\\d.]+){1,2}))?/\nvar RE_ROUTE = /^G0([01235])/\n\nvar parseCommentForFormatHints = function(parser, block, line) {\n var result = {}\n\n if (RE_KI_HINT.test(block)) {\n var kicadMatch = block.match(RE_KI_HINT)\n var leading = Number(kicadMatch[1])\n var trailing = Number(kicadMatch[2])\n var absolute = kicadMatch[3]\n var unitSet = kicadMatch[4]\n var suppressionSet = kicadMatch[5]\n\n // set format if we got numbers\n if (numIsFinite(leading) && numIsFinite(trailing)) {\n result.places = [leading, trailing]\n }\n\n // send backup notation\n if (absolute === 'absolute') {\n parser._push(commands.set('backupNota', 'A', line))\n } else {\n parser._push(commands.set('backupNota', 'I', line))\n }\n\n // send units\n if (unitSet === 'metric') {\n parser._push(commands.set('backupUnits', 'mm', line))\n } else {\n parser._push(commands.set('backupUnits', 'in', line))\n }\n\n // set zero suppression\n if (suppressionSet === 'leading' || suppressionSet === 'keep') {\n result.zero = 'L'\n } else if (suppressionSet === 'trailing') {\n result.zero = 'T'\n } else {\n result.zero = 'D'\n }\n } else if (RE_ALTIUM_HINT.test(block)) {\n // check for altium format hints if the format is not already set\n var altiumMatch = block.match(RE_ALTIUM_HINT)\n\n result.places = [Number(altiumMatch[1]), Number(altiumMatch[2])]\n } else if (RE_ALTIUM_PLATING_HINT.test(block)) {\n var platingMatch = block.match(RE_ALTIUM_PLATING_HINT)\n var holePlating = platingMatch[1] === 'PLATED' ? 'pth' : 'npth'\n parser._push(commands.set('holePlating', holePlating, line))\n }\n\n return result\n}\n\nvar parseUnits = function(parser, block, line) {\n var unitsMatch = block.match(RE_UNITS)\n var zeroMatch = block.match(RE_ZERO)\n var formatMatch = block.match(RE_FORMAT)\n var units =\n unitsMatch[1] === 'METRIC' || unitsMatch[1] === 'M71' ? 'mm' : 'in'\n\n var keep = zeroMatch && zeroMatch[1]\n\n if (parser.format.zero == null && keep) {\n // flip drill keep to gerber suppression\n parser.format.zero = keep === 'T' ? 'L' : 'T'\n }\n\n if (parser.format.places == null) {\n if (formatMatch) {\n parser.format.places = [formatMatch[1].length, formatMatch[2].length]\n } else {\n // by default, use 2.4 for inches and 3.3 for mm\n parser.format.places = units === 'in' ? [2, 4] : [3, 3]\n }\n }\n\n parser._push(commands.set('units', units, line))\n}\n\nvar coordToCommand = function(parser, block, line) {\n var coordMatch = block.match(RE_COORD)\n var coord = parseCoord.parse(coordMatch[1], parser.format)\n\n // if there's another match, then it was a slot\n if (coordMatch[2]) {\n parser._push(commands.op('move', coord, line))\n parser._push(commands.set('mode', 'i', line))\n coord = parseCoord.parse(coordMatch[2], parser.format)\n\n return parser._push(commands.op('int', coord, line))\n }\n\n // get the drill mode if a route command is present\n if (RE_ROUTE.test(block)) {\n parser._drillMode = block.match(RE_ROUTE)[1]\n }\n\n switch (parser._drillMode) {\n case drillMode.DRILL:\n return parser._push(commands.op('flash', coord, line))\n\n case drillMode.MOVE:\n return parser._push(commands.op('move', coord, line))\n\n case drillMode.LINEAR:\n parser._push(commands.set('mode', 'i', line))\n return parser._push(commands.op('int', coord, line))\n\n case drillMode.CW_ARC:\n parser._push(commands.set('mode', 'cw', line))\n return parser._push(commands.op('int', coord, line))\n\n case drillMode.CCW_ARC:\n parser._push(commands.set('mode', 'ccw', line))\n return parser._push(commands.op('int', coord, line))\n }\n}\n\nvar parseBlock = function(parser, block, line) {\n if (RE_TOOL_DEF.test(block)) {\n var toolMatch = block.match(RE_TOOL_DEF)\n var toolCode = toolMatch[1]\n var toolDia = normalize(toolMatch[2])\n var toolDef = {shape: 'circle', params: [toolDia], hole: []}\n\n return parser._push(commands.tool(toolCode, toolDef, line))\n }\n\n // tool set\n if (RE_TOOL_SET.test(block)) {\n var toolSet = block.match(RE_TOOL_SET)[1]\n\n // allow tool set to fall through because it can happen on the\n // same line as a coordinate operation\n parser._push(commands.set('tool', toolSet, line))\n }\n\n if (RE_COORD.test(block)) {\n if (!parser.format.places) {\n parser.format.places = [2, 4]\n parser._warn('places format missing; assuming [2, 4]')\n }\n\n if (!parser.format.zero) {\n parser.format.zero = 'T'\n parser._warn('zero suppression missing; assuming trailing suppression')\n }\n\n return coordToCommand(parser, block, line)\n }\n\n if (block === 'M00' || block === 'M30') {\n return parser._push(commands.done(line))\n }\n\n if (block === 'G90') {\n return parser._push(commands.set('nota', 'A', line))\n }\n\n if (block === 'G91') {\n return parser._push(commands.set('nota', 'I', line))\n }\n\n if (RE_UNITS.test(block)) {\n return parseUnits(parser, block, line)\n }\n}\n\nvar flush = function(parser) {\n parser._drillStash.forEach(function(data) {\n parseBlock(parser, data.block, data.line)\n })\n parser._drillStash = []\n}\n\nvar parse = function(parser, block) {\n if (block[0] === ';') {\n // if comment, parse it for formatting hints\n var formatHints = parseCommentForFormatHints(parser, block, parser.line)\n\n Object.keys(formatHints).forEach(function(key) {\n if (!parser.format[key]) {\n parser.format[key] = formatHints[key]\n }\n })\n } else if (!parser.format.zero) {\n // else if we don't have zero suppress yet, attempt to detect it\n parser._drillStash.push({line: parser.line, block: block})\n\n if (RE_COORD.test(block)) {\n parser.format.zero = parseCoord.detectZero(block)\n\n if (parser.format.zero) {\n parser._warn(\n 'zero suppression missing; detected ' +\n (parser.format.zero === 'L' ? 'leading' : 'trailing') +\n ' suppression'\n )\n }\n }\n\n if (\n parser.format.zero ||\n RE_ZERO.test(block) ||\n parser._drillStash.length >= 1000\n ) {\n flush(parser)\n }\n } else {\n // else just parse the block like normal\n parseBlock(parser, block, parser.line)\n }\n}\n\nmodule.exports = {parse: parse, flush: flush}\n","// simple warning class to be emitted when something questionable in the gerber is found\n'use strict'\n\nvar warning = function(message, line) {\n return {message: message, line: line}\n}\n\nmodule.exports = warning\n","// gerber-plotter factory\n'use strict'\n\nvar Plotter = require('./lib/plotter')\n\nvar verifyNota = function(nota) {\n if (nota === 'A' || nota === 'I') {\n return nota\n }\n\n throw new Error('notation must be \"in\" or \"mm\"')\n}\n\nvar verifyUnits = function(units) {\n if (units === 'in' || units === 'mm') {\n return units\n }\n\n throw new Error('units must be \"in\" or \"mm\"')\n}\n\nmodule.exports = function plotterFactory(options) {\n options = options || {}\n\n var units = options.units ? verifyUnits(options.units) : null\n var backupUnits = options.backupUnits\n ? verifyUnits(options.backupUnits)\n : null\n\n var nota = options.nota ? verifyNota(options.nota) : null\n var backupNota = options.backupNota ? verifyNota(options.backupNota) : null\n\n return new Plotter(\n units,\n backupUnits,\n nota,\n backupNota,\n options.optimizePaths,\n options.plotAsOutline\n )\n}\n","// gerber plotter\n'use strict'\n\nvar Transform = require('readable-stream').Transform\nvar inherits = require('inherits')\n\nvar PathGraph = require('./path-graph')\nvar warning = require('./_warning')\nvar padShape = require('./_pad-shape')\nvar operate = require('./_operate')\nvar boundingBox = require('./_box')\n\nvar MAX_GAP = 0.00011\n\nvar isFormatKey = function(key) {\n return (\n key === 'units' ||\n key === 'backupUnits' ||\n key === 'nota' ||\n key === 'backupNota'\n )\n}\n\nvar Plotter = function(\n units,\n backupUnits,\n nota,\n backupNota,\n optimizePaths,\n plotAsOutline\n) {\n Transform.call(this, {\n readableObjectMode: true,\n writableObjectMode: true,\n })\n\n this.format = {\n units: units,\n backupUnits: backupUnits || 'in',\n nota: nota,\n backupNota: backupNota || 'A',\n }\n\n this._formatLock = {\n units: units != null,\n backupUnits: backupUnits != null,\n nota: nota != null,\n backupNota: backupNota != null,\n }\n\n this._plotAsOutline = plotAsOutline === true ? MAX_GAP : plotAsOutline\n\n // plotAsOutline parameter is always in mm\n if ((units || this.format.backupUnits) === 'in') {\n this._plotAsOutline = this._plotAsOutline / 25.4\n }\n\n this._optimizePaths = optimizePaths || plotAsOutline\n\n this._line = 0\n this._done = false\n this._tool = null\n this._outTool = null\n this._tools = {}\n this._macros = {}\n this._pos = [0, 0]\n this._box = boundingBox.new()\n this._mode = null\n this._arc = null\n this._region = false\n this._path = new PathGraph(this._optimizePaths, this._plotAsOutline)\n this._epsilon = null\n this._lastOp = null\n this._stepRep = []\n}\n\ninherits(Plotter, Transform)\n\nPlotter.prototype._finishPath = function(doNotOptimize) {\n var path = this._path.traverse()\n this._path = new PathGraph(\n !doNotOptimize && this._optimizePaths,\n this._plotAsOutline\n )\n\n if (path.length) {\n // check for outline tool\n var tool = !this._plotAsOutline ? this._tool : this._outTool\n\n if (!this._region && tool.trace.length === 1) {\n this.push({type: 'stroke', width: tool.trace[0], path: path})\n } else {\n this.push({type: 'fill', path: path})\n }\n }\n}\n\nPlotter.prototype._warn = function(message) {\n this.emit('warning', warning(message, this._line))\n}\n\nPlotter.prototype._checkFormat = function() {\n if (!this.format.units) {\n this.format.units = this.format.backupUnits\n this._warn('units not set; using backup units: ' + this.format.units)\n }\n\n if (!this.format.nota) {\n this.format.nota = this.format.backupNota\n this._warn('notation not set; using backup notation: ' + this.format.nota)\n }\n}\n\nPlotter.prototype._updateBox = function(box) {\n var stepRepLen = this._stepRep.length\n if (!stepRepLen) {\n this._box = boundingBox.add(this._box, box)\n } else {\n var repeatBox = boundingBox.repeat(box, this._stepRep[stepRepLen - 1])\n this._box = boundingBox.add(this._box, repeatBox)\n }\n}\n\nPlotter.prototype._transform = function(chunk, encoding, done) {\n var type = chunk.type\n this._line = chunk.line\n\n if (this._done) {\n this._warn('ignoring extra command recieved after done command')\n\n return done()\n }\n\n // check for an operation\n if (type === 'op') {\n this._checkFormat()\n\n var op = chunk.op\n var coord = chunk.coord\n\n if (this.nota === 'I') {\n var _this = this\n\n coord = Object.keys(coord).reduce(function(result, key) {\n var value = coord[key]\n\n if (key === 'x') {\n result[key] = _this._pos[0] + value\n } else if (key === 'y') {\n result[key] = _this._pos[1] + value\n } else {\n result[key] = value\n }\n\n return result\n }, {})\n }\n\n if (op === 'last') {\n this._warn('modal operation commands are deprecated')\n op = this._lastOp\n }\n\n if (op === 'int') {\n if (this._mode == null) {\n this._warn('no interpolation mode specified; assuming linear')\n this._mode = 'i'\n }\n\n if (this._arc == null && this._mode.slice(-2) === 'cw' && !coord.a) {\n this._warn('quadrant mode unspecified; assuming single quadrant')\n this._arc = 's'\n }\n }\n\n if (this._plotAsOutline) {\n this._outTool = this._tool\n }\n\n var result = operate(\n op,\n coord,\n this._pos,\n this._tool,\n this._mode,\n this._arc,\n this._region || this._plotAsOutline,\n this._path,\n this._epsilon,\n this\n )\n\n this._lastOp = op\n this._pos = result.pos\n this._updateBox(result.box)\n } else if (type === 'set') {\n var prop = chunk.prop\n var value = chunk.value\n\n // if region change, finish the path\n if (prop === 'region') {\n this._finishPath(value)\n this._region = value\n } else if (isFormatKey(prop) && !this._formatLock[prop]) {\n // else we might need to set the format\n this.format[prop] = value\n if (prop === 'units' || prop === 'nota') {\n this._formatLock[prop] = true\n }\n } else if (prop === 'tool') {\n // else if we're dealing with a tool change, finish the path and change\n if (this._region) {\n this._warn('cannot change tool while region mode is on')\n } else if (!this._tools[value]) {\n this._warn('tool ' + value + ' is not defined')\n } else if (!this._outTool) {\n this._finishPath()\n this._tool = this._tools[value]\n }\n } else {\n // else set interpolation or arc mode\n this['_' + prop] = value\n }\n } else if (type === 'tool') {\n // else tool commands\n var code = chunk.code\n var toolDef = chunk.tool\n\n if (this._tools[code]) {\n this._warn(\n 'tool ' + code + ' is already defined; ignoring new definition'\n )\n\n return done()\n }\n\n var shapeAndBox = padShape(toolDef, this._macros)\n var tool = {\n code: code,\n trace: [],\n pad: shapeAndBox.shape,\n flashed: false,\n box: shapeAndBox.box,\n }\n\n if (toolDef.shape === 'circle' || toolDef.shape === 'rect') {\n if (toolDef.hole.length === 0) {\n tool.trace = toolDef.params\n }\n }\n\n if (!this._outTool) {\n this._finishPath()\n this._tools[code] = tool\n this._tool = tool\n }\n } else if (type === 'macro') {\n this._macros[chunk.name] = chunk.blocks\n } else if (type === 'level') {\n var level = chunk.level\n var levelValue = chunk.value\n\n this._finishPath()\n\n if (level === 'polarity') {\n this.push({\n type: 'polarity',\n polarity: levelValue === 'C' ? 'clear' : 'dark',\n box: this._box.slice(0),\n })\n } else {\n // calculate new offsets\n var offsets = []\n if (levelValue.x > 1 || levelValue.y > 1) {\n for (var x = 0; x < levelValue.x; x++) {\n for (var y = 0; y < levelValue.y; y++) {\n offsets.push([x * levelValue.i, y * levelValue.j])\n }\n }\n }\n\n this._stepRep = offsets\n\n this.push({\n type: 'repeat',\n offsets: this._stepRep.slice(0),\n box: this._box.slice(0),\n })\n }\n } else if (type === 'done') {\n this._done = true\n }\n\n return done()\n}\n\nPlotter.prototype._flush = function(done) {\n this._finishPath()\n\n this.push({type: 'size', box: this._box, units: this.format.units})\n done()\n}\n\nmodule.exports = Plotter\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\nexports.finished = require('./lib/internal/streams/end-of-stream.js');\nexports.pipeline = require('./lib/internal/streams/pipeline.js');\n","'use strict';\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar _require = require('buffer'),\n Buffer = _require.Buffer;\n\nvar _require2 = require('util'),\n inspect = _require2.inspect;\n\nvar custom = inspect && inspect.custom || 'inspect';\n\nfunction copyBuffer(src, target, offset) {\n Buffer.prototype.copy.call(src, target, offset);\n}\n\nmodule.exports =\n/*#__PURE__*/\nfunction () {\n function BufferList() {\n this.head = null;\n this.tail = null;\n this.length = 0;\n }\n\n var _proto = BufferList.prototype;\n\n _proto.push = function push(v) {\n var entry = {\n data: v,\n next: null\n };\n if (this.length > 0) this.tail.next = entry;else this.head = entry;\n this.tail = entry;\n ++this.length;\n };\n\n _proto.unshift = function unshift(v) {\n var entry = {\n data: v,\n next: this.head\n };\n if (this.length === 0) this.tail = entry;\n this.head = entry;\n ++this.length;\n };\n\n _proto.shift = function shift() {\n if (this.length === 0) return;\n var ret = this.head.data;\n if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n --this.length;\n return ret;\n };\n\n _proto.clear = function clear() {\n this.head = this.tail = null;\n this.length = 0;\n };\n\n _proto.join = function join(s) {\n if (this.length === 0) return '';\n var p = this.head;\n var ret = '' + p.data;\n\n while (p = p.next) {\n ret += s + p.data;\n }\n\n return ret;\n };\n\n _proto.concat = function concat(n) {\n if (this.length === 0) return Buffer.alloc(0);\n var ret = Buffer.allocUnsafe(n >>> 0);\n var p = this.head;\n var i = 0;\n\n while (p) {\n copyBuffer(p.data, ret, i);\n i += p.data.length;\n p = p.next;\n }\n\n return ret;\n } // Consumes a specified amount of bytes or characters from the buffered data.\n ;\n\n _proto.consume = function consume(n, hasStrings) {\n var ret;\n\n if (n < this.head.data.length) {\n // `slice` is the same for buffers and strings.\n ret = this.head.data.slice(0, n);\n this.head.data = this.head.data.slice(n);\n } else if (n === this.head.data.length) {\n // First chunk is a perfect match.\n ret = this.shift();\n } else {\n // Result spans more than one buffer.\n ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n }\n\n return ret;\n };\n\n _proto.first = function first() {\n return this.head.data;\n } // Consumes a specified amount of characters from the buffered data.\n ;\n\n _proto._getString = function _getString(n) {\n var p = this.head;\n var c = 1;\n var ret = p.data;\n n -= ret.length;\n\n while (p = p.next) {\n var str = p.data;\n var nb = n > str.length ? str.length : n;\n if (nb === str.length) ret += str;else ret += str.slice(0, n);\n n -= nb;\n\n if (n === 0) {\n if (nb === str.length) {\n ++c;\n if (p.next) this.head = p.next;else this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = str.slice(nb);\n }\n\n break;\n }\n\n ++c;\n }\n\n this.length -= c;\n return ret;\n } // Consumes a specified amount of bytes from the buffered data.\n ;\n\n _proto._getBuffer = function _getBuffer(n) {\n var ret = Buffer.allocUnsafe(n);\n var p = this.head;\n var c = 1;\n p.data.copy(ret);\n n -= p.data.length;\n\n while (p = p.next) {\n var buf = p.data;\n var nb = n > buf.length ? buf.length : n;\n buf.copy(ret, ret.length - n, 0, nb);\n n -= nb;\n\n if (n === 0) {\n if (nb === buf.length) {\n ++c;\n if (p.next) this.head = p.next;else this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = buf.slice(nb);\n }\n\n break;\n }\n\n ++c;\n }\n\n this.length -= c;\n return ret;\n } // Make sure the linked list only shows the minimal necessary information.\n ;\n\n _proto[custom] = function (_, options) {\n return inspect(this, _objectSpread({}, options, {\n // Only inspect one level.\n depth: 0,\n // It should not recurse.\n customInspect: false\n }));\n };\n\n return BufferList;\n}();","'use strict'\n\nvar experimentalWarnings = new Set();\n\nfunction emitExperimentalWarning(feature) {\n if (experimentalWarnings.has(feature)) return;\n var msg = feature + ' is an experimental feature. This feature could ' +\n 'change at any time';\n experimentalWarnings.add(feature);\n process.emitWarning(msg, 'ExperimentalWarning');\n}\n\nfunction noop() {}\n\nmodule.exports.emitExperimentalWarning = process.emitWarning\n ? emitExperimentalWarning\n : noop;\n","'use strict';\n\nvar _Object$setPrototypeO;\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar finished = require('./end-of-stream');\n\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\n\nfunction createIterResult(value, done) {\n return {\n value: value,\n done: done\n };\n}\n\nfunction readAndResolve(iter) {\n var resolve = iter[kLastResolve];\n\n if (resolve !== null) {\n var data = iter[kStream].read(); // we defer if data is null\n // we can be expecting either 'end' or\n // 'error'\n\n if (data !== null) {\n iter[kLastPromise] = null;\n iter[kLastResolve] = null;\n iter[kLastReject] = null;\n resolve(createIterResult(data, false));\n }\n }\n}\n\nfunction onReadable(iter) {\n // we wait for the next tick, because it might\n // emit an error with process.nextTick\n process.nextTick(readAndResolve, iter);\n}\n\nfunction wrapForNext(lastPromise, iter) {\n return function (resolve, reject) {\n lastPromise.then(function () {\n if (iter[kEnded]) {\n resolve(createIterResult(undefined, true));\n return;\n }\n\n iter[kHandlePromise](resolve, reject);\n }, reject);\n };\n}\n\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n get stream() {\n return this[kStream];\n },\n\n next: function next() {\n var _this = this;\n\n // if we have detected an error in the meanwhile\n // reject straight away\n var error = this[kError];\n\n if (error !== null) {\n return Promise.reject(error);\n }\n\n if (this[kEnded]) {\n return Promise.resolve(createIterResult(undefined, true));\n }\n\n if (this[kStream].destroyed) {\n // We need to defer via nextTick because if .destroy(err) is\n // called, the error will be emitted via nextTick, and\n // we cannot guarantee that there is no error lingering around\n // waiting to be emitted.\n return new Promise(function (resolve, reject) {\n process.nextTick(function () {\n if (_this[kError]) {\n reject(_this[kError]);\n } else {\n resolve(createIterResult(undefined, true));\n }\n });\n });\n } // if we have multiple next() calls\n // we will wait for the previous Promise to finish\n // this logic is optimized to support for await loops,\n // where next() is only called once at a time\n\n\n var lastPromise = this[kLastPromise];\n var promise;\n\n if (lastPromise) {\n promise = new Promise(wrapForNext(lastPromise, this));\n } else {\n // fast path needed to support multiple this.push()\n // without triggering the next() queue\n var data = this[kStream].read();\n\n if (data !== null) {\n return Promise.resolve(createIterResult(data, false));\n }\n\n promise = new Promise(this[kHandlePromise]);\n }\n\n this[kLastPromise] = promise;\n return promise;\n }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n var _this2 = this;\n\n // destroy(err, cb) is a private API\n // we can guarantee we have that here, because we control the\n // Readable class this is attached to\n return new Promise(function (resolve, reject) {\n _this2[kStream].destroy(null, function (err) {\n if (err) {\n reject(err);\n return;\n }\n\n resolve(createIterResult(undefined, true));\n });\n });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\n\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n var _Object$create;\n\n var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n value: stream,\n writable: true\n }), _defineProperty(_Object$create, kLastResolve, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kLastReject, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kError, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kEnded, {\n value: stream._readableState.endEmitted,\n writable: true\n }), _defineProperty(_Object$create, kHandlePromise, {\n value: function value(resolve, reject) {\n var data = iterator[kStream].read();\n\n if (data) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(data, false));\n } else {\n iterator[kLastResolve] = resolve;\n iterator[kLastReject] = reject;\n }\n },\n writable: true\n }), _Object$create));\n iterator[kLastPromise] = null;\n finished(stream, function (err) {\n if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise\n // returned by next() and store the error\n\n if (reject !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n reject(err);\n }\n\n iterator[kError] = err;\n return;\n }\n\n var resolve = iterator[kLastResolve];\n\n if (resolve !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(undefined, true));\n }\n\n iterator[kEnded] = true;\n });\n stream.on('readable', onReadable.bind(null, iterator));\n return iterator;\n};\n\nmodule.exports = createReadableStreamAsyncIterator;","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\nrequire('inherits')(PassThrough, Transform);\n\nfunction PassThrough(options) {\n if (!(this instanceof PassThrough)) return new PassThrough(options);\n Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n cb(null, chunk);\n};","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar eos;\n\nfunction once(callback) {\n var called = false;\n return function () {\n if (called) return;\n called = true;\n callback.apply(void 0, arguments);\n };\n}\n\nvar _require$codes = require('../../../errors').codes,\n ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\n\nfunction noop(err) {\n // Rethrow the error if it exists to avoid swallowing it\n if (err) throw err;\n}\n\nfunction isRequest(stream) {\n return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction destroyer(stream, reading, writing, callback) {\n callback = once(callback);\n var closed = false;\n stream.on('close', function () {\n closed = true;\n });\n if (eos === undefined) eos = require('./end-of-stream');\n eos(stream, {\n readable: reading,\n writable: writing\n }, function (err) {\n if (err) return callback(err);\n closed = true;\n callback();\n });\n var destroyed = false;\n return function (err) {\n if (closed) return;\n if (destroyed) return;\n destroyed = true; // request.destroy just do .end - .abort is what we want\n\n if (isRequest(stream)) return stream.abort();\n if (typeof stream.destroy === 'function') return stream.destroy();\n callback(err || new ERR_STREAM_DESTROYED('pipe'));\n };\n}\n\nfunction call(fn) {\n fn();\n}\n\nfunction pipe(from, to) {\n return from.pipe(to);\n}\n\nfunction popCallback(streams) {\n if (!streams.length) return noop;\n if (typeof streams[streams.length - 1] !== 'function') return noop;\n return streams.pop();\n}\n\nfunction pipeline() {\n for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n streams[_key] = arguments[_key];\n }\n\n var callback = popCallback(streams);\n if (Array.isArray(streams[0])) streams = streams[0];\n\n if (streams.length < 2) {\n throw new ERR_MISSING_ARGS('streams');\n }\n\n var error;\n var destroys = streams.map(function (stream, i) {\n var reading = i < streams.length - 1;\n var writing = i > 0;\n return destroyer(stream, reading, writing, function (err) {\n if (!error) error = err;\n if (err) destroys.forEach(call);\n if (reading) return;\n destroys.forEach(call);\n callback(error);\n });\n });\n return streams.reduce(pipe);\n}\n\nmodule.exports = pipeline;","// utilities to create a graph of path segments and traverse that graph\n'use strict'\n\nvar fill = require('lodash.fill')\n\nvar find = function(collection, condition) {\n var element\n var i\n\n for (i = 0; i < collection.length; i++) {\n element = collection[i]\n\n if (condition(element)) {\n return element\n }\n }\n}\n\nvar findClosest = function(points, position, fillGaps) {\n var result = points.reduce(\n function(prev, point) {\n var d = distance(position, point.position)\n if (d < fillGaps && d < prev.distance) {\n return {point: point, distance: d}\n }\n return prev\n },\n {point: undefined, distance: Infinity}\n )\n\n return result.point\n}\n\nvar distance = function(point, target) {\n return Math.sqrt(\n Math.pow(point[0] - target[0], 2) + Math.pow(point[1] - target[1], 2)\n )\n}\n\nvar pointsEqual = function(point, target) {\n return point[0] === target[0] && point[1] === target[1]\n}\n\nvar lineSegmentsEqual = function(segment, target) {\n return (\n segment.type === 'line' &&\n ((pointsEqual(segment.start, target.start) &&\n pointsEqual(segment.end, target.end)) ||\n (pointsEqual(segment.start, target.end) &&\n pointsEqual(segment.end, target.start)))\n )\n}\n\nvar reverseSegment = function(segment) {\n var reversed = {type: segment.type, start: segment.end, end: segment.start}\n\n if (segment.type === 'arc') {\n reversed.center = segment.center\n reversed.radius = segment.radius\n reversed.sweep = segment.sweep\n reversed.dir = segment.dir === 'cw' ? 'ccw' : 'cw'\n }\n\n return reversed\n}\n\nvar PathGraph = function(optimize, fillGaps) {\n this._edges = []\n this._optimize = optimize\n this._fillGaps = fillGaps\n this.length = 0\n}\n\nPathGraph.prototype.add = function(newSeg) {\n var edge = {segment: newSeg, start: newSeg.start, end: newSeg.end}\n this._edges.push(edge)\n this.length++\n}\n\nPathGraph.prototype._fillGapsAndOptimize = function() {\n var newSegs = this._edges.map(function(x) {\n return x.segment\n })\n this._edges = []\n this.length = 0\n var points = newSegs.reduce(function(prev, seg) {\n return prev.concat([\n {position: seg.start, edges: []},\n {position: seg.end, edges: []},\n ])\n }, [])\n\n var len = newSegs.length\n for (var i = 0; i < len; i++) {\n var newSeg = newSegs[i]\n var start\n var end\n var fillGaps = this._fillGaps\n\n var startIndex = i * 2\n var endIndex = startIndex + 1\n\n var otherPoints = points\n .slice(0, startIndex)\n .concat(points.slice(endIndex + 1))\n\n start = findClosest(otherPoints, newSeg.start, fillGaps)\n end = findClosest(otherPoints, newSeg.end, fillGaps)\n\n if (!start) {\n start = {position: newSeg.start, edges: []}\n } else if (fillGaps) {\n newSeg.start = start.position\n }\n\n if (!end) {\n end = {position: newSeg.end, edges: []}\n } else if (fillGaps) {\n newSeg.end = end.position\n }\n\n // do not allow duplicate line segments\n var existing = find(this._edges, function(edge) {\n return lineSegmentsEqual(edge.segment, newSeg)\n })\n\n if (!existing) {\n var newEdgeIndex = this._edges.length\n var edge = {segment: newSeg, start: start, end: end}\n\n points[startIndex].edges.push(newEdgeIndex)\n points[startIndex].position = edge.start.position\n points[endIndex].edges.push(newEdgeIndex)\n points[endIndex].position = edge.end.position\n\n this._edges.push(edge)\n this.length++\n }\n }\n\n // consolidate all the connecting edges to prepare for a depth first\n // traversal. depth first traversal is used so that when converted to an SVG\n // path it retains its shape. see discussion:\n // https://github.com/mcous/gerber-plotter/pull/13\n this._edges.forEach(function(edge) {\n points.forEach(function(point) {\n if (pointsEqual(point.position, edge.start.position)) {\n edge.start.edges = edge.start.edges.concat(point.edges)\n }\n if (pointsEqual(point.position, edge.end.position)) {\n edge.end.edges = edge.end.edges.concat(point.edges)\n }\n })\n })\n}\n\nPathGraph.prototype.traverse = function() {\n if (!this._optimize) {\n return this._edges.map(function(edge) {\n return edge.segment\n })\n }\n\n this._fillGapsAndOptimize()\n\n var walked = fill(Array(this._edges.length), false)\n var discovered = []\n var result = []\n\n var current\n var currentEdge\n var currentEnd\n var currentSegment\n var lastEnd = {position: []}\n\n while (result.length < this._edges.length) {\n current = walked.indexOf(false)\n discovered.push(current)\n\n while (discovered.length) {\n current = discovered.pop()\n\n if (!walked[current]) {\n walked[current] = true\n currentEdge = this._edges[current]\n currentEnd = currentEdge.end\n\n // reverse segment if necessary\n if (pointsEqual(lastEnd.position, currentEnd.position)) {\n currentSegment = reverseSegment(currentEdge.segment)\n lastEnd = currentEdge.start\n } else {\n currentSegment = currentEdge.segment\n lastEnd = currentEdge.end\n }\n\n // add non-walked adjacent nodes to the discovered stack\n lastEnd.edges.reverse().forEach(function(seg) {\n if (!walked[seg]) {\n discovered.push(seg)\n }\n })\n\n result.push(currentSegment)\n }\n }\n }\n\n return result\n}\n\nmodule.exports = PathGraph\n","/**\n * lodash (Custom Build) \n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors \n * Released under MIT license \n * Based on Underscore.js 1.8.3 \n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n MAX_SAFE_INTEGER = 9007199254740991,\n MAX_INTEGER = 1.7976931348623157e+308,\n NAN = 0 / 0;\n\n/** Used as references for the maximum length and index of an array. */\nvar MAX_ARRAY_LENGTH = 4294967295;\n\n/** `Object#toString` result references. */\nvar funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/**\n * The base implementation of `_.clamp` which doesn't coerce arguments.\n *\n * @private\n * @param {number} number The number to clamp.\n * @param {number} [lower] The lower bound.\n * @param {number} upper The upper bound.\n * @returns {number} Returns the clamped number.\n */\nfunction baseClamp(number, lower, upper) {\n if (number === number) {\n if (upper !== undefined) {\n number = number <= upper ? number : upper;\n }\n if (lower !== undefined) {\n number = number >= lower ? number : lower;\n }\n }\n return number;\n}\n\n/**\n * The base implementation of `_.fill` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to fill.\n * @param {*} value The value to fill `array` with.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns `array`.\n */\nfunction baseFill(array, value, start, end) {\n var length = array.length;\n\n start = toInteger(start);\n if (start < 0) {\n start = -start > length ? 0 : (length + start);\n }\n end = (end === undefined || end > length) ? length : toInteger(end);\n if (end < 0) {\n end += length;\n }\n end = start > end ? 0 : toLength(end);\n while (start < end) {\n array[start++] = value;\n }\n return array;\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n length = length == null ? MAX_SAFE_INTEGER : length;\n return !!length &&\n (typeof value == 'number' || reIsUint.test(value)) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n * else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n if (!isObject(object)) {\n return false;\n }\n var type = typeof index;\n if (type == 'number'\n ? (isArrayLike(object) && isIndex(index, object.length))\n : (type == 'string' && index in object)\n ) {\n return eq(object[index], value);\n }\n return false;\n}\n\n/**\n * Fills elements of `array` with `value` from `start` up to, but not\n * including, `end`.\n *\n * **Note:** This method mutates `array`.\n *\n * @static\n * @memberOf _\n * @since 3.2.0\n * @category Array\n * @param {Array} array The array to fill.\n * @param {*} value The value to fill `array` with.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = [1, 2, 3];\n *\n * _.fill(array, 'a');\n * console.log(array);\n * // => ['a', 'a', 'a']\n *\n * _.fill(Array(3), 2);\n * // => [2, 2, 2]\n *\n * _.fill([4, 6, 8, 10], '*', 1, 3);\n * // => [4, '*', '*', 10]\n */\nfunction fill(array, value, start, end) {\n var length = array ? array.length : 0;\n if (!length) {\n return [];\n }\n if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {\n start = 0;\n end = length;\n }\n return baseFill(array, value, start, end);\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 8-9 which returns 'object' for typed array and other constructors.\n var tag = isObject(value) ? objectToString.call(value) : '';\n return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n if (!value) {\n return value === 0 ? value : 0;\n }\n value = toNumber(value);\n if (value === INFINITY || value === -INFINITY) {\n var sign = (value < 0 ? -1 : 1);\n return sign * MAX_INTEGER;\n }\n return value === value ? value : 0;\n}\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n var result = toFinite(value),\n remainder = result % 1;\n\n return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\n/**\n * Converts `value` to an integer suitable for use as the length of an\n * array-like object.\n *\n * **Note:** This method is based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toLength(3.2);\n * // => 3\n *\n * _.toLength(Number.MIN_VALUE);\n * // => 0\n *\n * _.toLength(Infinity);\n * // => 4294967295\n *\n * _.toLength('3.2');\n * // => 3\n */\nfunction toLength(value) {\n return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n if (isObject(value)) {\n var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n value = isObject(other) ? (other + '') : other;\n }\n if (typeof value != 'string') {\n return value === 0 ? value : +value;\n }\n value = value.replace(reTrim, '');\n var isBinary = reIsBinary.test(value);\n return (isBinary || reIsOctal.test(value))\n ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = fill;\n","// simple warning\n'use strict'\n\nvar warning = function(message, line) {\n return {message: message, line: line}\n}\n\nmodule.exports = warning\n","// returns a pad shape array given a tool definition\n'use strict'\n\nvar isFunction = require('lodash.isfunction')\nvar isFinite = require('lodash.isfinite')\n\nvar boundingBox = require('./_box')\n\nvar roundToPrecision = function(number) {\n var rounded = Math.round(number * 100000000) / 100000000\n // remove -0 for ease\n if (rounded === 0) {\n return 0\n }\n return rounded\n}\n\nvar degreesToRadians = function(degrees) {\n return (degrees * Math.PI) / 180\n}\n\nvar rotatePointAboutOrigin = function(point, rot) {\n rot = degreesToRadians(rot)\n var sin = Math.sin(rot)\n var cos = Math.cos(rot)\n var x = point[0]\n var y = point[1]\n\n return [\n roundToPrecision(x * cos - y * sin),\n roundToPrecision(x * sin + y * cos),\n ]\n}\n\nvar circle = function(dia, cx, cy, rot) {\n var r = dia / 2\n cx = cx || 0\n cy = cy || 0\n\n // rotate cx and cy if necessary\n if (rot && (cx || cy)) {\n var rotatedCenter = rotatePointAboutOrigin([cx, cy], rot)\n cx = rotatedCenter[0]\n cy = rotatedCenter[1]\n }\n\n return {\n shape: {type: 'circle', cx: cx, cy: cy, r: dia / 2},\n box: boundingBox.addCircle(boundingBox.new(), r, cx, cy),\n }\n}\n\nvar vect = function(x1, y1, x2, y2, width, rot) {\n // rotate the endpoints if necessary\n if (rot) {\n var start = rotatePointAboutOrigin([x1, y1], rot)\n var end = rotatePointAboutOrigin([x2, y2], rot)\n x1 = start[0]\n y1 = start[1]\n x2 = end[0]\n y2 = end[1]\n }\n\n var m = (y2 - y1) / (x2 - x1)\n var hWidth = width / 2\n var sin = hWidth\n var cos = hWidth\n if (isFinite(m)) {\n sin *= m / Math.sqrt(1 + Math.pow(m, 2))\n cos *= 1 / Math.sqrt(1 + Math.pow(m, 2))\n } else {\n cos = 0\n }\n\n // add all four corners to the ponts array and the box\n var points = []\n points.push([roundToPrecision(x1 + sin), roundToPrecision(y1 - cos)])\n points.push([roundToPrecision(x2 + sin), roundToPrecision(y2 - cos)])\n points.push([roundToPrecision(x2 - sin), roundToPrecision(y2 + cos)])\n points.push([roundToPrecision(x1 - sin), roundToPrecision(y1 + cos)])\n\n var box = points.reduce(function(result, p) {\n return boundingBox.addPoint(result, p)\n }, boundingBox.new())\n\n return {\n shape: {type: 'poly', points: points},\n box: box,\n }\n}\n\nvar rect = function(width, height, r, cx, cy, rot) {\n cx = cx || 0\n cy = cy || 0\n r = r || 0\n rot = rot || 0\n\n var hWidth = width / 2\n var hHeight = height / 2\n\n if (rot) {\n var x1 = cx - hWidth\n var x2 = cx + hWidth\n var y1 = cy\n var y2 = cy\n\n return vect(x1, y1, x2, y2, height, rot)\n }\n\n return {\n shape: {type: 'rect', cx: cx, cy: cy, r: r, width: width, height: height},\n box: [-hWidth + cx, -hHeight + cy, hWidth + cx, hHeight + cy],\n }\n}\n\nvar outlinePolygon = function(flatPoints, rot) {\n var points = []\n var box = boundingBox.new()\n var point\n for (var i = 0; i < flatPoints.length - 2; i += 2) {\n point = [flatPoints[i], flatPoints[i + 1]]\n if (rot) {\n point = rotatePointAboutOrigin(point, rot)\n }\n\n points.push(point)\n box = boundingBox.addPoint(box, point)\n }\n\n return {\n shape: {type: 'poly', points: points},\n box: box,\n }\n}\n\nvar regularPolygon = function(dia, nPoints, rot, cx, cy) {\n cx = cx || 0\n cy = cy || 0\n\n var points = []\n var box = boundingBox.new()\n\n var r = dia / 2\n var offset = (rot * Math.PI) / 180\n var step = (2 * Math.PI) / nPoints\n var theta\n var x\n var y\n for (var n = 0; n < nPoints; n++) {\n theta = step * n + offset\n x = cx + roundToPrecision(r * Math.cos(theta))\n y = cy + roundToPrecision(r * Math.sin(theta))\n\n box = boundingBox.addPoint(box, [x, y])\n points.push([x, y])\n }\n\n return {\n shape: {type: 'poly', points: points},\n box: box,\n }\n}\n\n// just returns a ring object, does not return a box\nvar ring = function(cx, cy, r, width) {\n return {type: 'ring', cx: cx, cy: cy, r: r, width: width}\n}\n\nvar moire = function(\n dia,\n ringThx,\n ringGap,\n maxRings,\n crossThx,\n crossLen,\n cx,\n cy,\n rot\n) {\n var r = dia / 2\n var shape = []\n var box = boundingBox.addCircle(boundingBox.new(), r, cx, cy)\n var halfThx = ringThx / 2\n var gapAndHalfThx = ringGap + halfThx\n\n // add rings\n while (r > ringThx && shape.length < maxRings) {\n r -= halfThx\n shape.push(ring(cx, cy, roundToPrecision(r), ringThx))\n r -= gapAndHalfThx\n }\n\n // add a circle if necessary\n if (r > 0 && shape.length < maxRings) {\n shape.push(circle(roundToPrecision(2 * r), cx, cy).shape)\n }\n\n // add cross hairs\n var horCross = rect(crossLen, crossThx, 0, cx, cy, rot)\n var verCross = rect(crossThx, crossLen, 0, cx, cy, rot)\n shape.push(horCross.shape)\n shape.push(verCross.shape)\n box = boundingBox.add(box, horCross.box)\n box = boundingBox.add(box, verCross.box)\n\n return {shape: shape, box: box}\n}\n\nvar thermal = function(cx, cy, outerDia, innerDia, gap, rot) {\n var side = roundToPrecision((outerDia - gap) / 2)\n var offset = roundToPrecision((outerDia + gap) / 4)\n var width = roundToPrecision((outerDia - innerDia) / 2)\n var r = roundToPrecision((outerDia - width) / 2)\n var box = boundingBox.addCircle(boundingBox.new(), outerDia / 2, cx, cy)\n\n var rects = [\n rect(side, side, 0, cx + offset, cy + offset, rot).shape,\n rect(side, side, 0, cx - offset, cy + offset, rot).shape,\n rect(side, side, 0, cx - offset, cy - offset, rot).shape,\n rect(side, side, 0, cx + offset, cy - offset, rot).shape,\n ]\n var clip = ring(cx, cy, r, width)\n\n return {\n shape: {type: 'clip', shape: rects, clip: clip},\n box: box,\n }\n}\n\nvar runMacro = function(mods, blocks) {\n var emptyMacro = {shape: [], box: boundingBox.new()}\n var exposure = 1\n\n blocks = blocks || []\n\n return blocks.reduce(function(result, block) {\n var shapeAndBox\n\n if (block.type !== 'variable' && block.type !== 'comment') {\n block = Object.keys(block).reduce(function(result, key) {\n var value = block[key]\n\n if (isFunction(value)) {\n result[key] = value(mods)\n } else {\n result[key] = value\n }\n\n return result\n }, {})\n }\n\n if (block.exp != null && block.exp !== exposure) {\n result.shape.push({\n type: 'layer',\n polarity: block.exp === 1 ? 'dark' : 'clear',\n box: result.box.slice(0),\n })\n exposure = block.exp\n }\n\n switch (block.type) {\n case 'circle':\n shapeAndBox = circle(block.dia, block.cx, block.cy, block.rot)\n break\n\n case 'vect':\n shapeAndBox = vect(\n block.x1,\n block.y1,\n block.x2,\n block.y2,\n block.width,\n block.rot\n )\n break\n\n case 'rect':\n shapeAndBox = rect(\n block.width,\n block.height,\n 0,\n block.cx,\n block.cy,\n block.rot\n )\n break\n\n case 'rectLL':\n var hHeight = block.height / 2\n var hWidth = block.width / 2\n var cx = block.x + hWidth\n var cy = block.y + hHeight\n shapeAndBox = rect(block.width, block.height, 0, cx, cy, block.rot)\n break\n\n case 'outline':\n shapeAndBox = outlinePolygon(block.points, block.rot)\n break\n\n case 'poly':\n shapeAndBox = regularPolygon(\n block.dia,\n block.vertices,\n block.rot,\n block.cx,\n block.cy\n )\n break\n\n case 'moire':\n shapeAndBox = moire(\n block.dia,\n block.ringThx,\n block.ringGap,\n block.maxRings,\n block.crossThx,\n block.crossLen,\n block.cx,\n block.cy,\n block.rot\n )\n break\n\n case 'thermal':\n shapeAndBox = thermal(\n block.cx,\n block.cy,\n block.outerDia,\n block.innerDia,\n block.gap,\n block.rot\n )\n break\n\n case 'variable':\n mods = block.set(mods)\n return result\n\n default:\n return result\n }\n\n result.shape = result.shape.concat(shapeAndBox.shape)\n\n // only change the box if the exposure is creating an image\n if (exposure === 1) {\n result.box = boundingBox.add(result.box, shapeAndBox.box)\n }\n\n return result\n }, emptyMacro)\n}\n\nmodule.exports = function padShape(tool, macros) {\n var shape = []\n var box = boundingBox.new()\n var toolShape = tool.shape\n var params = tool.params\n var holeShape\n var shapeAndBox\n\n if (toolShape === 'circle') {\n shapeAndBox = circle(params[0])\n } else if (toolShape === 'rect') {\n shapeAndBox = rect(params[0], params[1])\n } else if (toolShape === 'obround') {\n shapeAndBox = rect(params[0], params[1], Math.min(params[0], params[1]) / 2)\n } else if (toolShape === 'poly') {\n shapeAndBox = regularPolygon(params[0], params[1], params[2])\n } else {\n // else we got a macro, so run the macro and return\n var mods = params.reduce(function(result, val, index) {\n result['$' + (index + 1)] = val\n\n return result\n }, {})\n\n return runMacro(mods, macros[toolShape])\n }\n\n // if we didn't return, we have a standard tool, so carry on accordingly\n shape.push(shapeAndBox.shape)\n box = boundingBox.add(box, shapeAndBox.box)\n\n if (tool.hole.length) {\n holeShape =\n tool.hole.length === 1\n ? circle(tool.hole[0]).shape\n : rect(tool.hole[0], tool.hole[1]).shape\n\n shape.push({type: 'layer', polarity: 'clear', box: box}, holeShape)\n }\n\n return {shape: shape, box: box}\n}\n","/**\n * Lodash (Custom Build) \n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright JS Foundation and other contributors \n * Released under MIT license \n * Based on Underscore.js 1.8.3 \n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n nullTag = '[object Null]',\n proxyTag = '[object Proxy]',\n undefinedTag = '[object Undefined]';\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar Symbol = root.Symbol,\n symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isFunction;\n","// operate the plotter\n'use strict'\n\nvar boundingBox = require('./_box')\n\nvar HALF_PI = Math.PI / 2\nvar PI = Math.PI\nvar TWO_PI = Math.PI * 2\nvar THREE_HALF_PI = (3 * Math.PI) / 2\n\n// flash operation\n// returns a bounding box for the operation\nvar flash = function(coord, tool, region, plotter) {\n // no flashing allowed in region mode\n if (region) {\n plotter._warn('flash in region ignored')\n return boundingBox.new()\n }\n\n // warn if tool was not defined\n if (!tool) {\n plotter._warn('flash with unknown tool ignored')\n return boundingBox.new()\n }\n\n // push the pad shape if needed\n if (!tool.flashed) {\n tool.flashed = true\n plotter.push({type: 'shape', tool: tool.code, shape: tool.pad})\n }\n\n plotter.push({type: 'pad', tool: tool.code, x: coord[0], y: coord[1]})\n return boundingBox.translate(tool.box, coord)\n}\n\n// given a start, end, direction, arc quadrant mode, and list of potential centers, find the\n// angles of the start and end points, the sweep angle, and the center\nvar findCenterAndAngles = function(start, end, mode, arc, centers) {\n var thetaStart\n var thetaEnd\n var sweep\n var candidate\n var center\n while (center == null && centers.length > 0) {\n candidate = centers.pop()\n thetaStart = Math.atan2(start[1] - candidate[1], start[0] - candidate[0])\n thetaEnd = Math.atan2(end[1] - candidate[1], end[0] - candidate[0])\n\n // in clockwise mode, ensure the start is greater than the end and check the sweep\n // do the opposite for counter-clockwise\n if (mode === 'cw') {\n thetaStart = thetaStart >= thetaEnd ? thetaStart : thetaStart + TWO_PI\n } else {\n thetaEnd = thetaEnd >= thetaStart ? thetaEnd : thetaEnd + TWO_PI\n }\n\n sweep = Math.abs(thetaStart - thetaEnd)\n\n // in single quadrant mode, the center is only valid if the sweep is less than 90 degrees\n // in multiquandrant mode there's only one candidate; we're within spec to assume it's good\n if (arc === 's') {\n if (sweep <= HALF_PI) {\n center = candidate\n }\n } else {\n center = candidate\n }\n }\n\n if (center == null) {\n return undefined\n }\n\n // ensure the thetas are [0, TWO_PI)\n thetaStart = thetaStart >= 0 ? thetaStart : thetaStart + TWO_PI\n thetaStart = thetaStart < TWO_PI ? thetaStart : thetaStart - TWO_PI\n thetaEnd = thetaEnd >= 0 ? thetaEnd : thetaEnd + TWO_PI\n thetaEnd = thetaEnd < TWO_PI ? thetaEnd : thetaEnd - TWO_PI\n\n return {\n center: center,\n sweep: sweep,\n start: start.concat(thetaStart),\n end: end.concat(thetaEnd),\n }\n}\n\nvar arcBox = function(cenAndAngles, r, region, tool, dir) {\n var startPoint = cenAndAngles.start\n var endPoint = cenAndAngles.end\n var center = cenAndAngles.center\n var sweep = cenAndAngles.sweep\n\n var start\n var end\n\n // normalize direction to counter-clockwise\n if (dir === 'cw') {\n start = endPoint[2]\n end = startPoint[2]\n } else {\n start = startPoint[2]\n end = endPoint[2]\n }\n\n // get bounding box definition points\n var points = [startPoint, endPoint]\n\n // check for sweep past 0 degrees\n if (start > end || sweep === TWO_PI) {\n points.push([center[0] + r, center[1]])\n }\n\n // rotate to check for sweep past 90 degrees\n start = start >= HALF_PI ? start - HALF_PI : start + THREE_HALF_PI\n end = end >= HALF_PI ? end - HALF_PI : end + THREE_HALF_PI\n if (start > end || sweep === TWO_PI) {\n points.push([center[0], center[1] + r])\n }\n\n // rotate again to check for sweep past 180 degrees\n start = start >= HALF_PI ? start - HALF_PI : start + THREE_HALF_PI\n end = end >= HALF_PI ? end - HALF_PI : end + THREE_HALF_PI\n if (start > end || sweep === TWO_PI) {\n points.push([center[0] - r, center[1]])\n }\n\n // rotate again to check for sweep past 270 degrees\n start = start >= HALF_PI ? start - HALF_PI : start + THREE_HALF_PI\n end = end >= HALF_PI ? end - HALF_PI : end + THREE_HALF_PI\n if (start > end || sweep === TWO_PI) {\n points.push([center[0], center[1] - r])\n }\n\n return points.reduce(function(result, m) {\n if (!region) {\n var mBox = boundingBox.translate(tool.box, m)\n return boundingBox.add(result, mBox)\n }\n\n return boundingBox.addPoint(result, m)\n }, boundingBox.new())\n}\n\nvar roundToZero = function(number, epsilon) {\n return number >= epsilon ? number : 0\n}\n\n// find the center of an arc given its endpoints and its radius\n// assume the arc is <= 180 degress\n// thank you this guy: http://math.stackexchange.com/a/87912\nvar arcCenterFromRadius = function(start, end, mode, epsilon, radius) {\n var sign = mode === 'ccw' ? 1 : -1\n var xAve = (start[0] + end[0]) / 2\n var yAve = (start[1] + end[1]) / 2\n var deltaX = end[0] - start[1]\n var deltaY = end[1] - start[1]\n var distance = Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2))\n var halfDistance = distance / 2\n var squareDifference = Math.sqrt(\n Math.pow(radius, 2) - Math.pow(halfDistance, 2)\n )\n var xOffset = (-sign * deltaY * squareDifference) / distance\n var yOffset = (sign * deltaX * squareDifference) / distance\n\n return [\n [\n roundToZero(xAve + xOffset, epsilon),\n roundToZero(yAve + yOffset, epsilon),\n ],\n ]\n}\n\nvar drawArc = function(\n start,\n end,\n offset,\n tool,\n mode,\n arc,\n region,\n epsilon,\n pathGraph,\n plotter\n) {\n // get the radius of the arc from the offsets\n var r =\n offset[2] || Math.sqrt(Math.pow(offset[0], 2) + Math.pow(offset[1], 2))\n\n // potential candidates for the arc center\n // in single quadrant mode, all offset signs are implicit, so we need to check a few\n var candidates = []\n var xCandidates = []\n var yCandidates = []\n\n if (offset[0] && arc === 's') {\n xCandidates.push(start[0] + offset[0], start[0] - offset[0])\n } else {\n xCandidates.push(start[0] + offset[0])\n }\n\n if (offset[1] && arc === 's') {\n yCandidates.push(start[1] + offset[1], start[1] - offset[1])\n } else {\n yCandidates.push(start[1] + offset[1])\n }\n\n for (var i = 0; i < xCandidates.length; i++) {\n for (var j = 0; j < yCandidates.length; j++) {\n candidates.push([xCandidates[i], yCandidates[j]])\n }\n }\n\n // find valid centers by comparing the distance to start and end for equality with the radius\n var validCenters\n if (offset[2]) {\n arc = 'm'\n validCenters = arcCenterFromRadius(start, end, mode, epsilon, offset[2])\n } else if (arc === 's') {\n validCenters = candidates.filter(function(c) {\n var startDist = Math.sqrt(\n Math.pow(c[0] - start[0], 2) + Math.pow(c[1] - start[1], 2)\n )\n var endDist = Math.sqrt(\n Math.pow(c[0] - end[0], 2) + Math.pow(c[1] - end[1], 2)\n )\n\n return (\n Math.abs(startDist - r) <= epsilon && Math.abs(endDist - r) <= epsilon\n )\n })\n } else {\n validCenters = candidates\n }\n\n var cenAndAngles = findCenterAndAngles(start, end, mode, arc, validCenters)\n\n // edge case: matching start and end in multi quadrant mode is a full circle\n if (arc === 'm' && start[0] === end[0] && start[1] === end[1]) {\n cenAndAngles.sweep = TWO_PI\n }\n\n var box = boundingBox.new()\n if (cenAndAngles != null) {\n pathGraph.add({\n type: 'arc',\n start: cenAndAngles.start,\n end: cenAndAngles.end,\n center: cenAndAngles.center,\n sweep: cenAndAngles.sweep,\n radius: r,\n dir: mode,\n })\n\n box = arcBox(cenAndAngles, r, region, tool, mode)\n } else {\n plotter._warn('skipping impossible arc')\n }\n\n return box\n}\n\nvar drawLine = function(start, end, tool, region, pathGraph) {\n pathGraph.add({type: 'line', start: start, end: end})\n\n if (!region) {\n var startBox = boundingBox.translate(tool.box, start)\n var endBox = boundingBox.translate(tool.box, end)\n return boundingBox.add(startBox, endBox)\n }\n\n var box = boundingBox.new()\n box = boundingBox.addPoint(box, start)\n box = boundingBox.addPoint(box, end)\n return box\n}\n\n// interpolate a rectangle and emit the fill immdeiately\nvar interpolateRect = function(start, end, tool, pathGraph, plotter) {\n var hWidth = tool.trace[0] / 2\n var hHeight = tool.trace[1] / 2\n var theta = Math.atan2(end[1] - start[1], end[0] - start[0])\n\n var sXMin = start[0] - hWidth\n var sXMax = start[0] + hWidth\n var sYMin = start[1] - hHeight\n var sYMax = start[1] + hHeight\n var eXMin = end[0] - hWidth\n var eXMax = end[0] + hWidth\n var eYMin = end[1] - hHeight\n var eYMax = end[1] + hHeight\n\n var points = []\n\n // no movement\n if (start[0] === end[0] && start[1] === end[1]) {\n points.push([sXMin, sYMin], [sXMax, sYMin], [sXMax, sYMax], [sXMin, sYMax])\n } else if (theta >= 0 && theta < HALF_PI) {\n // first quadrant move\n points.push(\n [sXMin, sYMin],\n [sXMax, sYMin],\n [eXMax, eYMin],\n [eXMax, eYMax],\n [eXMin, eYMax],\n [sXMin, sYMax]\n )\n } else if (theta >= HALF_PI && theta <= PI) {\n // second quadrant move\n points.push(\n [sXMax, sYMin],\n [sXMax, sYMax],\n [eXMax, eYMax],\n [eXMin, eYMax],\n [eXMin, eYMin],\n [sXMin, sYMin]\n )\n } else if (theta >= -PI && theta < -HALF_PI) {\n // third quadrant move\n points.push(\n [sXMax, sYMax],\n [sXMin, sYMax],\n [eXMin, eYMax],\n [eXMin, eYMin],\n [eXMax, eYMin],\n [sXMax, sYMin]\n )\n } else {\n // fourth quadrant move\n points.push(\n [sXMin, sYMax],\n [sXMin, sYMin],\n [eXMin, eYMin],\n [eXMax, eYMin],\n [eXMax, eYMax],\n [sXMax, sYMax]\n )\n }\n\n points.forEach(function(p, i) {\n var j = i < points.length - 1 ? i + 1 : 0\n pathGraph.add({type: 'line', start: p, end: points[j]})\n })\n\n plotter._finishPath()\n\n return boundingBox.add(\n boundingBox.translate(tool.box, start),\n boundingBox.translate(tool.box, end)\n )\n}\n\n// interpolate operation\n// returns a bounding box for the operation\nvar interpolate = function(\n start,\n end,\n offset,\n tool,\n mode,\n arc,\n region,\n epsilon,\n pathGraph,\n plotter\n) {\n if (!region && tool.trace.length === 0) {\n plotter._warn(\n 'tool ' + tool.code + ' is not strokable; ignoring interpolate'\n )\n return boundingBox.new()\n }\n\n if (mode === 'i') {\n // add a line to the path normally if region mode is on or the tool is a circle\n if (region || tool.trace.length === 1) {\n return drawLine(start, end, tool, region, pathGraph)\n }\n\n // else, the tool is a rectangle, which needs a special interpolation function\n return interpolateRect(start, end, tool, pathGraph, plotter)\n }\n\n // else, make sure we're allowed to be drawing an arc, then draw an arc\n if (tool.trace.length !== 1 && !region) {\n plotter._warn('cannot draw an arc with a non-circular tool')\n return boundingBox.new()\n }\n\n return drawArc(\n start,\n end,\n offset,\n tool,\n mode,\n arc,\n region,\n epsilon,\n pathGraph,\n plotter\n )\n}\n\n// takes the start point, the op type, the op coords, the tool, and the push function\n// returns the new plotter position\nvar operate = function(\n type,\n coord,\n start,\n tool,\n mode,\n arc,\n region,\n pathGraph,\n epsilon,\n plotter\n) {\n var end = [\n coord.x != null ? coord.x : start[0],\n coord.y != null ? coord.y : start[1],\n ]\n\n var offset = [\n coord.i != null ? coord.i : 0,\n coord.j != null ? coord.j : 0,\n coord.a,\n ]\n\n var box\n switch (type) {\n case 'flash':\n box = flash(end, tool, region, plotter)\n break\n\n case 'int':\n box = interpolate(\n start,\n end,\n offset,\n tool,\n mode,\n arc,\n region,\n epsilon,\n pathGraph,\n plotter\n )\n break\n\n default:\n box = boundingBox.new()\n break\n }\n\n return {\n pos: end,\n box: box,\n }\n}\n\nmodule.exports = operate\n","/*!\n * escape-html\n * Copyright(c) 2012-2013 TJ Holowaychuk\n * Copyright(c) 2015 Andreas Lubbe\n * Copyright(c) 2015 Tiancheng \"Timothy\" Gu\n * MIT Licensed\n */\n\n'use strict';\n\n/**\n * Module variables.\n * @private\n */\n\nvar matchHtmlRegExp = /[\"'&<>]/;\n\n/**\n * Module exports.\n * @public\n */\n\nmodule.exports = escapeHtml;\n\n/**\n * Escape special characters in the given string of html.\n *\n * @param {string} string The string to escape for inserting into HTML\n * @return {string}\n * @public\n */\n\nfunction escapeHtml(string) {\n var str = '' + string;\n var match = matchHtmlRegExp.exec(str);\n\n if (!match) {\n return str;\n }\n\n var escape;\n var html = '';\n var index = 0;\n var lastIndex = 0;\n\n for (index = match.index; index < str.length; index++) {\n switch (str.charCodeAt(index)) {\n case 34: // \"\n escape = '"';\n break;\n case 38: // &\n escape = '&';\n break;\n case 39: // '\n escape = ''';\n break;\n case 60: // <\n escape = '<';\n break;\n case 62: // >\n escape = '>';\n break;\n default:\n continue;\n }\n\n if (lastIndex !== index) {\n html += str.substring(lastIndex, index);\n }\n\n lastIndex = index + 1;\n html += escape;\n }\n\n return lastIndex !== index\n ? html + str.substring(lastIndex, index)\n : html;\n}\n","// transform stream to take plotter objects and convert them to an SVG string\n'use strict'\n\nvar Transform = require('readable-stream').Transform\nvar inherits = require('inherits')\nvar isFinite = require('lodash.isfinite')\n\nvar reduceShapeArray = require('./_reduce-shape')\nvar flashPad = require('./_flash-pad')\nvar createPath = require('./_create-path')\nvar util = require('./_util')\nvar render = require('../render')\n\nvar shift = util.shift\nvar maskLayer = util.maskLayer\nvar createMask = util.createMask\n\nvar BLOCK_MODE_OFF = 0\nvar BLOCK_MODE_DARK = 1\nvar BLOCK_MODE_CLEAR = 2\n\nvar PlotterToSvg = function(id, attributes, createElement, objectMode) {\n Transform.call(this, {\n writableObjectMode: true,\n readableObjectMode: objectMode,\n })\n\n this.id = id\n this.attributes = attributes\n this.defs = []\n this.layer = []\n this.viewBox = [0, 0, 0, 0]\n this.width = 0\n this.height = 0\n this.units = ''\n\n this._maskId = ''\n this._maskBox = []\n this._mask = []\n this._blockMode = false\n this._blockBox = []\n this._block = []\n this._blockCount = 0\n this._blockLayerCount = 0\n this._offsets = []\n this._clearCount = 0\n this._lastLayer = 0\n this._blockCount = 0\n this._blockCount = 0\n\n this._element = createElement\n}\n\ninherits(PlotterToSvg, Transform)\n\nPlotterToSvg.prototype._transform = function(chunk, encoding, done) {\n switch (chunk.type) {\n case 'shape':\n this.defs = this.defs.concat(\n reduceShapeArray(this.id, chunk.tool, chunk.shape, this._element)\n )\n break\n\n case 'pad':\n this._draw(flashPad(this.id, chunk.tool, chunk.x, chunk.y, this._element))\n break\n\n case 'fill':\n this._draw(createPath(chunk.path, null, this._element))\n break\n\n case 'stroke':\n this._draw(createPath(chunk.path, chunk.width, this._element))\n break\n\n case 'polarity':\n this._handleNewPolarity(chunk.polarity, chunk.box)\n break\n\n case 'repeat':\n this._handleNewRepeat(chunk.offsets, chunk.box)\n break\n\n case 'size':\n this._handleSize(chunk.box, chunk.units)\n }\n\n done()\n}\n\nPlotterToSvg.prototype._flush = function(done) {\n // shut off step repeat finish any in-progress clear layer and/or repeat\n this._handleNewRepeat([])\n this.push(render(this, this.attributes, this._element))\n done()\n}\n\nPlotterToSvg.prototype._finishBlockLayer = function() {\n // if there's a block, wrap it up, give it an id, and repeat it\n if (this._block.length) {\n this._blockLayerCount++\n\n var blockLayerId =\n this.id + '_block-' + this._blockCount + '-' + this._blockLayerCount\n\n this.defs.push(this._element('g', {id: blockLayerId}, this._block))\n\n this._block = []\n }\n}\n\nPlotterToSvg.prototype._finishClearLayer = function() {\n if (this._maskId) {\n this.defs.push(\n createMask(this._maskId, this._maskBox, this._mask, this._element)\n )\n this._maskId = ''\n this._maskBox = []\n this._mask = []\n\n return true\n }\n\n return false\n}\n\nPlotterToSvg.prototype._handleNewPolarity = function(polarity, box) {\n if (this._blockMode) {\n if (this._blockLayerCount === 0 && !this._block.length) {\n this._blockMode = polarity === 'dark' ? BLOCK_MODE_DARK : BLOCK_MODE_CLEAR\n }\n\n return this._finishBlockLayer()\n }\n\n this._clearCount =\n polarity === 'clear' ? this._clearCount + 1 : this._clearCount\n var maskId = this.id + '_clear-' + this._clearCount\n\n // if clear polarity, wrap the layer and start a mask\n if (polarity === 'clear') {\n this.layer = [maskLayer(maskId, this.layer, this._element)]\n this._maskId = maskId\n this._maskBox = box.slice(0)\n } else {\n // else, finish the mask and add it to the defs\n this._finishClearLayer(box)\n }\n}\n\nPlotterToSvg.prototype._handleNewRepeat = function(offsets, box) {\n var endOfBlock = offsets.length === 0\n\n // finish any in progress clear layer and block layer\n var wasClear = this._finishClearLayer()\n\n this._finishBlockLayer()\n\n var layer = this.layer\n var element = this._element\n var blockMode = this._blockMode\n var blockLayers = this._blockLayerCount\n var blockIdStart = this.id + '_block-' + this._blockCount + '-'\n\n // add dark layers to layer\n this._offsets.forEach(function(offset) {\n for (var i = blockMode; i <= blockLayers; i += 2) {\n layer.push(\n element('use', {\n 'xlink:href': '#' + blockIdStart + i,\n x: shift(offset[0]),\n y: shift(offset[1]),\n })\n )\n }\n })\n\n // if there are clear layers in the block, mask the layer with them\n if (blockLayers > 2 - blockMode) {\n var maskId = blockIdStart + 'clear'\n\n this.layer = [maskLayer(maskId, layer, this._element)]\n this._maskId = maskId\n this._maskBox = this._blockBox.slice(0)\n this._mask = this._offsets.reduce(function(result, offset) {\n var isDark\n\n for (var i = 1; i <= blockLayers; i++) {\n isDark = blockMode === BLOCK_MODE_DARK ? i % 2 === 1 : i % 2 === 0\n\n var attr = {\n 'xlink:href': '#' + blockIdStart + i,\n x: shift(offset[0]),\n y: shift(offset[1]),\n }\n\n if (isDark) {\n attr.fill = '#fff'\n attr.stroke = '#fff'\n }\n\n result.push(element('use', attr))\n }\n\n return result\n }, [])\n\n wasClear = this._finishClearLayer()\n }\n\n // save the offsets\n this._offsets = offsets\n if (!endOfBlock) {\n this._blockMode = !wasClear ? BLOCK_MODE_DARK : BLOCK_MODE_CLEAR\n this._blockCount++\n this._blockLayerCount = 0\n this._blockBox = box.every(isFinite) ? box : [0, 0, 0, 0]\n } else {\n this._blockMode = BLOCK_MODE_OFF\n }\n}\n\nPlotterToSvg.prototype._handleSize = function(box, units) {\n if (box.every(isFinite)) {\n var x = shift(box[0])\n var y = shift(box[1])\n var width = shift(box[2] - box[0])\n var height = shift(box[3] - box[1])\n\n this.viewBox = [x, y, width, height]\n this.width = width / 1000\n this.height = height / 1000\n this.units = units\n }\n}\n\nPlotterToSvg.prototype._draw = function(object) {\n if (!this._blockMode) {\n if (!this._maskId) {\n this.layer.push(object)\n } else {\n this._mask.push(object)\n }\n } else {\n this._block.push(object)\n }\n}\n\nmodule.exports = PlotterToSvg\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\nexports.finished = require('./lib/internal/streams/end-of-stream.js');\nexports.pipeline = require('./lib/internal/streams/pipeline.js');\n","'use strict';\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar _require = require('buffer'),\n Buffer = _require.Buffer;\n\nvar _require2 = require('util'),\n inspect = _require2.inspect;\n\nvar custom = inspect && inspect.custom || 'inspect';\n\nfunction copyBuffer(src, target, offset) {\n Buffer.prototype.copy.call(src, target, offset);\n}\n\nmodule.exports =\n/*#__PURE__*/\nfunction () {\n function BufferList() {\n this.head = null;\n this.tail = null;\n this.length = 0;\n }\n\n var _proto = BufferList.prototype;\n\n _proto.push = function push(v) {\n var entry = {\n data: v,\n next: null\n };\n if (this.length > 0) this.tail.next = entry;else this.head = entry;\n this.tail = entry;\n ++this.length;\n };\n\n _proto.unshift = function unshift(v) {\n var entry = {\n data: v,\n next: this.head\n };\n if (this.length === 0) this.tail = entry;\n this.head = entry;\n ++this.length;\n };\n\n _proto.shift = function shift() {\n if (this.length === 0) return;\n var ret = this.head.data;\n if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n --this.length;\n return ret;\n };\n\n _proto.clear = function clear() {\n this.head = this.tail = null;\n this.length = 0;\n };\n\n _proto.join = function join(s) {\n if (this.length === 0) return '';\n var p = this.head;\n var ret = '' + p.data;\n\n while (p = p.next) {\n ret += s + p.data;\n }\n\n return ret;\n };\n\n _proto.concat = function concat(n) {\n if (this.length === 0) return Buffer.alloc(0);\n var ret = Buffer.allocUnsafe(n >>> 0);\n var p = this.head;\n var i = 0;\n\n while (p) {\n copyBuffer(p.data, ret, i);\n i += p.data.length;\n p = p.next;\n }\n\n return ret;\n } // Consumes a specified amount of bytes or characters from the buffered data.\n ;\n\n _proto.consume = function consume(n, hasStrings) {\n var ret;\n\n if (n < this.head.data.length) {\n // `slice` is the same for buffers and strings.\n ret = this.head.data.slice(0, n);\n this.head.data = this.head.data.slice(n);\n } else if (n === this.head.data.length) {\n // First chunk is a perfect match.\n ret = this.shift();\n } else {\n // Result spans more than one buffer.\n ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n }\n\n return ret;\n };\n\n _proto.first = function first() {\n return this.head.data;\n } // Consumes a specified amount of characters from the buffered data.\n ;\n\n _proto._getString = function _getString(n) {\n var p = this.head;\n var c = 1;\n var ret = p.data;\n n -= ret.length;\n\n while (p = p.next) {\n var str = p.data;\n var nb = n > str.length ? str.length : n;\n if (nb === str.length) ret += str;else ret += str.slice(0, n);\n n -= nb;\n\n if (n === 0) {\n if (nb === str.length) {\n ++c;\n if (p.next) this.head = p.next;else this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = str.slice(nb);\n }\n\n break;\n }\n\n ++c;\n }\n\n this.length -= c;\n return ret;\n } // Consumes a specified amount of bytes from the buffered data.\n ;\n\n _proto._getBuffer = function _getBuffer(n) {\n var ret = Buffer.allocUnsafe(n);\n var p = this.head;\n var c = 1;\n p.data.copy(ret);\n n -= p.data.length;\n\n while (p = p.next) {\n var buf = p.data;\n var nb = n > buf.length ? buf.length : n;\n buf.copy(ret, ret.length - n, 0, nb);\n n -= nb;\n\n if (n === 0) {\n if (nb === buf.length) {\n ++c;\n if (p.next) this.head = p.next;else this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = buf.slice(nb);\n }\n\n break;\n }\n\n ++c;\n }\n\n this.length -= c;\n return ret;\n } // Make sure the linked list only shows the minimal necessary information.\n ;\n\n _proto[custom] = function (_, options) {\n return inspect(this, _objectSpread({}, options, {\n // Only inspect one level.\n depth: 0,\n // It should not recurse.\n customInspect: false\n }));\n };\n\n return BufferList;\n}();","'use strict'\n\nvar experimentalWarnings = new Set();\n\nfunction emitExperimentalWarning(feature) {\n if (experimentalWarnings.has(feature)) return;\n var msg = feature + ' is an experimental feature. This feature could ' +\n 'change at any time';\n experimentalWarnings.add(feature);\n process.emitWarning(msg, 'ExperimentalWarning');\n}\n\nfunction noop() {}\n\nmodule.exports.emitExperimentalWarning = process.emitWarning\n ? emitExperimentalWarning\n : noop;\n","'use strict';\n\nvar _Object$setPrototypeO;\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar finished = require('./end-of-stream');\n\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\n\nfunction createIterResult(value, done) {\n return {\n value: value,\n done: done\n };\n}\n\nfunction readAndResolve(iter) {\n var resolve = iter[kLastResolve];\n\n if (resolve !== null) {\n var data = iter[kStream].read(); // we defer if data is null\n // we can be expecting either 'end' or\n // 'error'\n\n if (data !== null) {\n iter[kLastPromise] = null;\n iter[kLastResolve] = null;\n iter[kLastReject] = null;\n resolve(createIterResult(data, false));\n }\n }\n}\n\nfunction onReadable(iter) {\n // we wait for the next tick, because it might\n // emit an error with process.nextTick\n process.nextTick(readAndResolve, iter);\n}\n\nfunction wrapForNext(lastPromise, iter) {\n return function (resolve, reject) {\n lastPromise.then(function () {\n if (iter[kEnded]) {\n resolve(createIterResult(undefined, true));\n return;\n }\n\n iter[kHandlePromise](resolve, reject);\n }, reject);\n };\n}\n\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n get stream() {\n return this[kStream];\n },\n\n next: function next() {\n var _this = this;\n\n // if we have detected an error in the meanwhile\n // reject straight away\n var error = this[kError];\n\n if (error !== null) {\n return Promise.reject(error);\n }\n\n if (this[kEnded]) {\n return Promise.resolve(createIterResult(undefined, true));\n }\n\n if (this[kStream].destroyed) {\n // We need to defer via nextTick because if .destroy(err) is\n // called, the error will be emitted via nextTick, and\n // we cannot guarantee that there is no error lingering around\n // waiting to be emitted.\n return new Promise(function (resolve, reject) {\n process.nextTick(function () {\n if (_this[kError]) {\n reject(_this[kError]);\n } else {\n resolve(createIterResult(undefined, true));\n }\n });\n });\n } // if we have multiple next() calls\n // we will wait for the previous Promise to finish\n // this logic is optimized to support for await loops,\n // where next() is only called once at a time\n\n\n var lastPromise = this[kLastPromise];\n var promise;\n\n if (lastPromise) {\n promise = new Promise(wrapForNext(lastPromise, this));\n } else {\n // fast path needed to support multiple this.push()\n // without triggering the next() queue\n var data = this[kStream].read();\n\n if (data !== null) {\n return Promise.resolve(createIterResult(data, false));\n }\n\n promise = new Promise(this[kHandlePromise]);\n }\n\n this[kLastPromise] = promise;\n return promise;\n }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n var _this2 = this;\n\n // destroy(err, cb) is a private API\n // we can guarantee we have that here, because we control the\n // Readable class this is attached to\n return new Promise(function (resolve, reject) {\n _this2[kStream].destroy(null, function (err) {\n if (err) {\n reject(err);\n return;\n }\n\n resolve(createIterResult(undefined, true));\n });\n });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\n\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n var _Object$create;\n\n var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n value: stream,\n writable: true\n }), _defineProperty(_Object$create, kLastResolve, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kLastReject, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kError, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kEnded, {\n value: stream._readableState.endEmitted,\n writable: true\n }), _defineProperty(_Object$create, kHandlePromise, {\n value: function value(resolve, reject) {\n var data = iterator[kStream].read();\n\n if (data) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(data, false));\n } else {\n iterator[kLastResolve] = resolve;\n iterator[kLastReject] = reject;\n }\n },\n writable: true\n }), _Object$create));\n iterator[kLastPromise] = null;\n finished(stream, function (err) {\n if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise\n // returned by next() and store the error\n\n if (reject !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n reject(err);\n }\n\n iterator[kError] = err;\n return;\n }\n\n var resolve = iterator[kLastResolve];\n\n if (resolve !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(undefined, true));\n }\n\n iterator[kEnded] = true;\n });\n stream.on('readable', onReadable.bind(null, iterator));\n return iterator;\n};\n\nmodule.exports = createReadableStreamAsyncIterator;","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\nrequire('inherits')(PassThrough, Transform);\n\nfunction PassThrough(options) {\n if (!(this instanceof PassThrough)) return new PassThrough(options);\n Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n cb(null, chunk);\n};","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar eos;\n\nfunction once(callback) {\n var called = false;\n return function () {\n if (called) return;\n called = true;\n callback.apply(void 0, arguments);\n };\n}\n\nvar _require$codes = require('../../../errors').codes,\n ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\n\nfunction noop(err) {\n // Rethrow the error if it exists to avoid swallowing it\n if (err) throw err;\n}\n\nfunction isRequest(stream) {\n return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction destroyer(stream, reading, writing, callback) {\n callback = once(callback);\n var closed = false;\n stream.on('close', function () {\n closed = true;\n });\n if (eos === undefined) eos = require('./end-of-stream');\n eos(stream, {\n readable: reading,\n writable: writing\n }, function (err) {\n if (err) return callback(err);\n closed = true;\n callback();\n });\n var destroyed = false;\n return function (err) {\n if (closed) return;\n if (destroyed) return;\n destroyed = true; // request.destroy just do .end - .abort is what we want\n\n if (isRequest(stream)) return stream.abort();\n if (typeof stream.destroy === 'function') return stream.destroy();\n callback(err || new ERR_STREAM_DESTROYED('pipe'));\n };\n}\n\nfunction call(fn) {\n fn();\n}\n\nfunction pipe(from, to) {\n return from.pipe(to);\n}\n\nfunction popCallback(streams) {\n if (!streams.length) return noop;\n if (typeof streams[streams.length - 1] !== 'function') return noop;\n return streams.pop();\n}\n\nfunction pipeline() {\n for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n streams[_key] = arguments[_key];\n }\n\n var callback = popCallback(streams);\n if (Array.isArray(streams[0])) streams = streams[0];\n\n if (streams.length < 2) {\n throw new ERR_MISSING_ARGS('streams');\n }\n\n var error;\n var destroys = streams.map(function (stream, i) {\n var reading = i < streams.length - 1;\n var writing = i > 0;\n return destroyer(stream, reading, writing, function (err) {\n if (!error) error = err;\n if (err) destroys.forEach(call);\n if (reading) return;\n destroys.forEach(call);\n callback(error);\n });\n });\n return streams.reduce(pipe);\n}\n\nmodule.exports = pipeline;","// reduce a shape array into a string to place is defs\n'use strict'\n\nvar util = require('./_util')\nvar shift = util.shift\nvar createMask = util.createMask\nvar maskLayer = util.maskLayer\n\nvar element = function(tag, attr, children) {\n return {tag: tag, attr: attr, children: children || []}\n}\n\nvar circle = function(cx, cy, r, width) {\n var attr = {\n cx: shift(cx),\n cy: shift(cy),\n r: shift(r),\n }\n\n if (width != null) {\n attr['stroke-width'] = shift(width)\n attr.fill = 'none'\n }\n\n return element('circle', attr)\n}\n\nvar rect = function(cx, cy, r, width, height) {\n var attr = {\n x: shift(cx - width / 2),\n y: shift(cy - height / 2),\n width: shift(width),\n height: shift(height),\n }\n\n if (r) {\n attr.rx = shift(r)\n attr.ry = shift(r)\n }\n\n return element('rect', attr)\n}\n\nvar poly = function(points) {\n var pointsAttr = points\n .map(function(point) {\n return point.map(shift).join(',')\n })\n .join(' ')\n\n return element('polygon', {points: pointsAttr})\n}\n\nvar clip = function(maskIdPrefix, index, shapes, ring, createElement) {\n var maskId = maskIdPrefix + 'mask-' + index\n var maskUrl = 'url(#' + maskId + ')'\n\n var circleNode = circle(ring.cx, ring.cy, ring.r, ring.width)\n\n var mask = createElement('mask', {id: maskId, stroke: '#fff'}, [\n createElement(circleNode.tag, circleNode.attr),\n ])\n\n var groupChildren = shapes.map(function(shape) {\n var node =\n shape.type === 'rect'\n ? rect(shape.cx, shape.cy, shape.r, shape.width, shape.height)\n : poly(shape.points)\n\n return createElement(node.tag, node.attr)\n })\n\n var layer = element('g', {mask: maskUrl}, groupChildren)\n\n return {mask: mask, layer: layer}\n}\n\nmodule.exports = function reduceShapeArray(\n prefix,\n code,\n shapeArray,\n createElement\n) {\n var id = prefix + '_pad-' + code\n var maskIdPrefix = id + '_'\n\n var image = shapeArray.reduce(\n function(result, shape, index) {\n var svg\n\n switch (shape.type) {\n case 'circle':\n svg = circle(shape.cx, shape.cy, shape.r)\n break\n\n case 'ring':\n svg = circle(shape.cx, shape.cy, shape.r, shape.width)\n break\n\n case 'rect':\n svg = rect(shape.cx, shape.cy, shape.r, shape.width, shape.height)\n break\n\n case 'poly':\n svg = poly(shape.points)\n break\n\n case 'clip':\n var clipNodes = clip(\n maskIdPrefix,\n index,\n shape.shape,\n shape.clip,\n createElement\n )\n\n result.masks.push(clipNodes.mask)\n svg = clipNodes.layer\n break\n\n case 'layer':\n result.count++\n result.last = shape.polarity\n\n // if the polarity is clear, wrap the group and start a mask\n if (shape.polarity === 'clear') {\n var nextMaskId = maskIdPrefix + result.count\n\n result.maskId = nextMaskId\n result.maskBox = shape.box.slice(0)\n result.maskChildren = []\n result.layers = [\n maskLayer(nextMaskId, result.layers, createElement),\n ]\n } else {\n var mask = createMask(\n result.maskId,\n result.maskBox,\n result.maskChildren,\n createElement\n )\n\n result.masks.push(mask)\n }\n break\n }\n\n if (svg) {\n if (shapeArray.length === 1) {\n svg.attr.id = id\n }\n\n var svgElement = createElement(svg.tag, svg.attr, svg.children)\n\n if (result.last === 'dark') {\n result.layers.push(svgElement)\n } else {\n result.maskChildren.push(svgElement)\n }\n }\n\n return result\n },\n {\n count: 0,\n last: 'dark',\n layers: [],\n maskId: '',\n maskBox: [],\n maskChildren: [],\n masks: [],\n }\n )\n\n if (image.last === 'clear') {\n image.masks.push(\n createMask(image.maskId, image.maskBox, image.maskChildren, createElement)\n )\n }\n\n if (shapeArray.length > 1) {\n image.layers = createElement('g', {id: id}, image.layers)\n }\n\n return image.masks.concat(image.layers)\n}\n","// creates the SVG for a pad flash\n'use strict'\n\nvar util = require('./_util')\nvar shift = util.shift\n\nmodule.exports = function flashPad(prefix, tool, x, y, element) {\n var toolId = '#' + prefix + '_pad-' + tool\n\n return element('use', {'xlink:href': toolId, x: shift(x), y: shift(y)})\n}\n","// create a path from a fill or stroke object\n'use strict'\n\nvar util = require('./_util')\nvar shift = util.shift\n\nvar pointsEqual = function(point, target) {\n return point[0] === target[0] && point[1] === target[1]\n}\n\nvar move = function(start) {\n return 'M ' + shift(start[0]) + ' ' + shift(start[1])\n}\n\nvar line = function(lastCmd, end) {\n var cmd = lastCmd === 'L' || lastCmd === 'M' ? '' : 'L '\n\n return cmd + shift(end[0]) + ' ' + shift(end[1])\n}\n\nvar arc = function(lastCmd, radius, sweep, dir, end, center) {\n // add zero-length arcs as zero-length lines to render properly across all browsers\n if (sweep === 0) {\n return line(lastCmd, end)\n }\n\n // full-circle arcs must be rendered as two separate arcs\n if (sweep === 2 * Math.PI) {\n var half = [2 * center[0] - end[0], 2 * center[1] - end[1]]\n\n var arc1 = arc(lastCmd, radius, Math.PI, dir, half, center)\n var arc2 = arc('A', radius, Math.PI, dir, end, center)\n\n return arc1 + ' ' + arc2\n }\n\n var result = lastCmd === 'A' ? '' : 'A '\n\n radius = shift(radius)\n result += radius + ' ' + radius + ' 0 '\n result += sweep > Math.PI ? '1 ' : '0 '\n result += dir === 'ccw' ? '1 ' : '0 '\n result += shift(end[0]) + ' ' + shift(end[1])\n\n return result\n}\n\nvar reduceSegments = function(result, segment) {\n var type = segment.type\n var start = segment.start\n var end = segment.end\n\n if (!pointsEqual(result.last, start)) {\n result.data += (result.data ? ' ' : '') + move(start)\n result.lastCmd = 'M'\n }\n\n result.data += ' '\n if (type === 'line') {\n result.data += line(result.lastCmd, end)\n result.lastCmd = 'L'\n } else {\n result.data += arc(\n result.lastCmd,\n segment.radius,\n segment.sweep,\n segment.dir,\n end,\n segment.center\n )\n\n result.lastCmd = 'A'\n }\n\n result.last = end\n\n return result\n}\n\nmodule.exports = function createPath(segments, width, element) {\n var pathData = segments.reduce(reduceSegments, {last: [], data: ''}).data\n var attr = {d: pathData}\n\n if (width != null) {\n attr.fill = 'none'\n attr['stroke-width'] = shift(width)\n }\n\n return element('path', attr)\n}\n","// main pcb stackup function\n'use strict'\n\nvar extend = require('xtend')\nvar wtg = require('whats-that-gerber')\nvar vb = require('viewbox')\n\nvar boardColor = require('./lib/board-color')\nvar parseOptions = require('./lib/parse-options')\nvar sortLayers = require('./lib/sort-layers')\nvar stackLayers = require('./lib/stack-layers')\n\nvar SIDES = [wtg.SIDE_TOP, wtg.SIDE_BOTTOM]\n\nvar BASE_ATTRIBUTES = {\n version: '1.1',\n xmlns: 'http://www.w3.org/2000/svg',\n 'xmlns:dc': \"http://purl.org/dc/elements/1.1/\",\n 'xmlns:cc': \"http://creativecommons.org/ns#\",\n 'xmlns:rdf': \"http://www.w3.org/1999/02/22-rdf-syntax-ns#\",\n 'xmlns:svg': \"http://www.w3.org/2000/svg\",\n 'xmlns:sodipodi': \"http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd\",\n 'xmlns:inkscape': \"http://www.inkscape.org/namespaces/inkscape\",\n 'xmlns:xlink': 'http://www.w3.org/1999/xlink',\n 'stroke-linecap': 'round',\n 'stroke-linejoin': 'round',\n 'stroke-width': 0,\n 'fill-rule': 'evenodd',\n 'clip-rule': 'evenodd',\n}\n\nvar INSNS_B64 = require('./lib/instruction_svg_template_b64')\n\nmodule.exports = function pcbStackupCore(layers, inputOpts) {\n var options = parseOptions(inputOpts)\n var sorted = sortLayers(layers)\n\n var id = options.id\n var color = options.color\n var attributes = options.attributes\n var useOutline = options.useOutline\n var element = options.createElement\n\n var stacks = SIDES.map(function(side) {\n return stackLayers(\n element,\n id,\n side,\n sorted[side],\n sorted.drills,\n sorted.outline,\n useOutline,\n true\n )\n })\n\n var box = stacks.reduce(function(result, stack) {\n return vb.add(result, stack.box)\n }, vb.create())\n\n if (box.length !== 4) box = [0, 0, 0, 0]\n\n return stacks.reduce(function(result, stack, index) {\n var side = SIDES[index]\n var style = boardColor.getStyleElement(element, id + '_', side, color)\n var units = stack.units\n var mechMaskId = stack.mechMaskId\n var outClipId = stack.outClipId\n var view = ``\n var defs = [style].concat(stack.defs)\n defs.push(element('radialGradient', {id: 'BackgroundGradient'}, [\n element('stop', {offset: '0%', 'stop-color': 'white'}),\n element('stop', {offset: '100%', 'stop-color': 'black', 'stop-opacity': '0'})\n ]))\n var layer = [\n element(\n 'g',\n getGroupAttributes(box, side, mechMaskId, outClipId),\n stack.layer\n ),\n ]\n var layerPads = [\n element(\n 'g',\n getGroupAttributes(box, side),\n stack.copies\n ),\n ]\n var layerOutline = [\n element(\n 'g',\n getGroupAttributes(box, side),\n [stack.outline]\n ),\n ]\n\n var defsNode = element('defs', {}, defs)\n var layerNode = element('g', getLayerAttributes(box), layer)\n var padsNode = element('g', getLayerAttributes(box), layerPads)\n var outlineNode = element('g', getLayerAttributes(box), layerOutline)\n var sideAttributes = extend(\n BASE_ATTRIBUTES,\n {\n id: id + '_' + side,\n viewBox: vb.asString(box),\n width: box[2] / 1000 + units,\n height: box[3] / 1000 + units,\n },\n attributes\n )\n\n var insnsNode = element('g', {\n id: 'insns_group',\n transform: `translate(${box[0] - 155000}, ${box[1] - 95000})`,\n }, [INSNS_B64])\n var backgroundRect = element('rect',\n {x: box[0], y: box[1], width: box[2], height: box[3], fill: 'url(#BackgroundGradient)'})\n\n var inkscapeLayerBackground = element('g',\n {'inkscape:groupmode': 'layer',\n 'inkscape:label': 'Background',\n 'sodipodi:insensitive': true,\n 'id': 'inscape_layer_insns'\n }, [backgroundRect])\n\n var inkscapeLayerInsns = element('g',\n {'inkscape:groupmode': 'layer',\n 'inkscape:label': 'Instructions',\n 'sodipodi:insensitive': true,\n 'id': 'inscape_layer_insns',\n }, [insnsNode])\n\n var inkscapeLayerRender = element('g',\n {'inkscape:groupmode': 'layer',\n 'inkscape:label': 'Board Render',\n 'sodipodi:insensitive': true,\n 'id': 'inscape_layer_render'\n }, [layerNode])\n\n var inkscapeLayerPads = element('g',\n {'inkscape:groupmode': 'layer',\n 'inkscape:label': 'Pads',\n 'id': 'inscape_layer_pads'\n }, [padsNode])\n\n var inkscapeLayerOutline = element('g',\n {'inkscape:groupmode': 'layer',\n 'inkscape:label': 'Outline',\n 'sodipodi:insensitive': true,\n 'id': 'inscape_layer_outline'\n }, [outlineNode])\n\n var inkscapeLayerTPs = element('g',\n {'inkscape:groupmode': 'layer',\n 'inkscape:label': 'Test Points',\n 'id': 'inscape_layer_tps'\n }, [])\n\n var inkscapeLayerMount = element('g',\n {'inkscape:groupmode': 'layer',\n 'inkscape:label': 'Mounting Holes',\n 'id': 'inscape_layer_mount'\n }, [])\n\n var inkscapeLayerGrip = element('g',\n {'inkscape:groupmode': 'layer',\n 'inkscape:label': 'Grip Slots',\n 'id': 'inscape_layer_grip'\n }, [])\n\n result[side] = {\n svg: element('svg', sideAttributes, [\n view,\n defsNode,\n inkscapeLayerBackground,\n inkscapeLayerInsns,\n inkscapeLayerRender,\n inkscapeLayerPads,\n inkscapeLayerOutline,\n inkscapeLayerGrip,\n inkscapeLayerMount,\n inkscapeLayerTPs]),\n attributes: sideAttributes,\n defs: defs,\n layer: layer,\n viewBox: box,\n width: box[2] / 1000,\n height: box[3] / 1000,\n units: units,\n }\n\n return result\n }, options)\n}\n\nfunction getGroupAttributes(box, side, mechMaskId, outClipId) {\n var attr = {}\n\n if (mechMaskId) {\n attr['mask'] = 'url(#' + mechMaskId + ')'\n }\n\n if (outClipId) {\n attr['clip-path'] = 'url(#' + outClipId + ')'\n }\n\n // flip the bottom render in the x\n if (side === wtg.SIDE_BOTTOM) {\n var xTranslation = 2 * box[0] + box[2]\n attr.transform = 'translate(' + xTranslation + ',0) scale(-1,1)'\n }\n\n return attr\n}\n\nfunction getLayerAttributes(box) {\n var yTranslation = 2 * box[1] + box[3]\n return {transform: 'translate(0,' + yTranslation + ') scale(1,-1)'}\n}\n","/* MIT license */\nvar colorNames = require('color-name');\nvar swizzle = require('simple-swizzle');\n\nvar reverseNames = {};\n\n// create a list of reverse color names\nfor (var name in colorNames) {\n\tif (colorNames.hasOwnProperty(name)) {\n\t\treverseNames[colorNames[name]] = name;\n\t}\n}\n\nvar cs = module.exports = {\n\tto: {},\n\tget: {}\n};\n\ncs.get = function (string) {\n\tvar prefix = string.substring(0, 3).toLowerCase();\n\tvar val;\n\tvar model;\n\tswitch (prefix) {\n\t\tcase 'hsl':\n\t\t\tval = cs.get.hsl(string);\n\t\t\tmodel = 'hsl';\n\t\t\tbreak;\n\t\tcase 'hwb':\n\t\t\tval = cs.get.hwb(string);\n\t\t\tmodel = 'hwb';\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tval = cs.get.rgb(string);\n\t\t\tmodel = 'rgb';\n\t\t\tbreak;\n\t}\n\n\tif (!val) {\n\t\treturn null;\n\t}\n\n\treturn {model: model, value: val};\n};\n\ncs.get.rgb = function (string) {\n\tif (!string) {\n\t\treturn null;\n\t}\n\n\tvar abbr = /^#([a-f0-9]{3,4})$/i;\n\tvar hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i;\n\tvar rgba = /^rgba?\\(\\s*([+-]?\\d+)\\s*,\\s*([+-]?\\d+)\\s*,\\s*([+-]?\\d+)\\s*(?:,\\s*([+-]?[\\d\\.]+)\\s*)?\\)$/;\n\tvar per = /^rgba?\\(\\s*([+-]?[\\d\\.]+)\\%\\s*,\\s*([+-]?[\\d\\.]+)\\%\\s*,\\s*([+-]?[\\d\\.]+)\\%\\s*(?:,\\s*([+-]?[\\d\\.]+)\\s*)?\\)$/;\n\tvar keyword = /(\\D+)/;\n\n\tvar rgb = [0, 0, 0, 1];\n\tvar match;\n\tvar i;\n\tvar hexAlpha;\n\n\tif (match = string.match(hex)) {\n\t\thexAlpha = match[2];\n\t\tmatch = match[1];\n\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\t// https://jsperf.com/slice-vs-substr-vs-substring-methods-long-string/19\n\t\t\tvar i2 = i * 2;\n\t\t\trgb[i] = parseInt(match.slice(i2, i2 + 2), 16);\n\t\t}\n\n\t\tif (hexAlpha) {\n\t\t\trgb[3] = Math.round((parseInt(hexAlpha, 16) / 255) * 100) / 100;\n\t\t}\n\t} else if (match = string.match(abbr)) {\n\t\tmatch = match[1];\n\t\thexAlpha = match[3];\n\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\trgb[i] = parseInt(match[i] + match[i], 16);\n\t\t}\n\n\t\tif (hexAlpha) {\n\t\t\trgb[3] = Math.round((parseInt(hexAlpha + hexAlpha, 16) / 255) * 100) / 100;\n\t\t}\n\t} else if (match = string.match(rgba)) {\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\trgb[i] = parseInt(match[i + 1], 0);\n\t\t}\n\n\t\tif (match[4]) {\n\t\t\trgb[3] = parseFloat(match[4]);\n\t\t}\n\t} else if (match = string.match(per)) {\n\t\tfor (i = 0; i < 3; i++) {\n\t\t\trgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);\n\t\t}\n\n\t\tif (match[4]) {\n\t\t\trgb[3] = parseFloat(match[4]);\n\t\t}\n\t} else if (match = string.match(keyword)) {\n\t\tif (match[1] === 'transparent') {\n\t\t\treturn [0, 0, 0, 0];\n\t\t}\n\n\t\trgb = colorNames[match[1]];\n\n\t\tif (!rgb) {\n\t\t\treturn null;\n\t\t}\n\n\t\trgb[3] = 1;\n\n\t\treturn rgb;\n\t} else {\n\t\treturn null;\n\t}\n\n\tfor (i = 0; i < 3; i++) {\n\t\trgb[i] = clamp(rgb[i], 0, 255);\n\t}\n\trgb[3] = clamp(rgb[3], 0, 1);\n\n\treturn rgb;\n};\n\ncs.get.hsl = function (string) {\n\tif (!string) {\n\t\treturn null;\n\t}\n\n\tvar hsl = /^hsla?\\(\\s*([+-]?(?:\\d*\\.)?\\d+)(?:deg)?\\s*,\\s*([+-]?[\\d\\.]+)%\\s*,\\s*([+-]?[\\d\\.]+)%\\s*(?:,\\s*([+-]?[\\d\\.]+)\\s*)?\\)$/;\n\tvar match = string.match(hsl);\n\n\tif (match) {\n\t\tvar alpha = parseFloat(match[4]);\n\t\tvar h = (parseFloat(match[1]) + 360) % 360;\n\t\tvar s = clamp(parseFloat(match[2]), 0, 100);\n\t\tvar l = clamp(parseFloat(match[3]), 0, 100);\n\t\tvar a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);\n\n\t\treturn [h, s, l, a];\n\t}\n\n\treturn null;\n};\n\ncs.get.hwb = function (string) {\n\tif (!string) {\n\t\treturn null;\n\t}\n\n\tvar hwb = /^hwb\\(\\s*([+-]?\\d*[\\.]?\\d+)(?:deg)?\\s*,\\s*([+-]?[\\d\\.]+)%\\s*,\\s*([+-]?[\\d\\.]+)%\\s*(?:,\\s*([+-]?[\\d\\.]+)\\s*)?\\)$/;\n\tvar match = string.match(hwb);\n\n\tif (match) {\n\t\tvar alpha = parseFloat(match[4]);\n\t\tvar h = ((parseFloat(match[1]) % 360) + 360) % 360;\n\t\tvar w = clamp(parseFloat(match[2]), 0, 100);\n\t\tvar b = clamp(parseFloat(match[3]), 0, 100);\n\t\tvar a = clamp(isNaN(alpha) ? 1 : alpha, 0, 1);\n\t\treturn [h, w, b, a];\n\t}\n\n\treturn null;\n};\n\ncs.to.hex = function () {\n\tvar rgba = swizzle(arguments);\n\n\treturn (\n\t\t'#' +\n\t\thexDouble(rgba[0]) +\n\t\thexDouble(rgba[1]) +\n\t\thexDouble(rgba[2]) +\n\t\t(rgba[3] < 1\n\t\t\t? (hexDouble(Math.round(rgba[3] * 255)))\n\t\t\t: '')\n\t);\n};\n\ncs.to.rgb = function () {\n\tvar rgba = swizzle(arguments);\n\n\treturn rgba.length < 4 || rgba[3] === 1\n\t\t? 'rgb(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ')'\n\t\t: 'rgba(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ', ' + rgba[3] + ')';\n};\n\ncs.to.rgb.percent = function () {\n\tvar rgba = swizzle(arguments);\n\n\tvar r = Math.round(rgba[0] / 255 * 100);\n\tvar g = Math.round(rgba[1] / 255 * 100);\n\tvar b = Math.round(rgba[2] / 255 * 100);\n\n\treturn rgba.length < 4 || rgba[3] === 1\n\t\t? 'rgb(' + r + '%, ' + g + '%, ' + b + '%)'\n\t\t: 'rgba(' + r + '%, ' + g + '%, ' + b + '%, ' + rgba[3] + ')';\n};\n\ncs.to.hsl = function () {\n\tvar hsla = swizzle(arguments);\n\treturn hsla.length < 4 || hsla[3] === 1\n\t\t? 'hsl(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%)'\n\t\t: 'hsla(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%, ' + hsla[3] + ')';\n};\n\n// hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax\n// (hwb have alpha optional & 1 is default value)\ncs.to.hwb = function () {\n\tvar hwba = swizzle(arguments);\n\n\tvar a = '';\n\tif (hwba.length >= 4 && hwba[3] !== 1) {\n\t\ta = ', ' + hwba[3];\n\t}\n\n\treturn 'hwb(' + hwba[0] + ', ' + hwba[1] + '%, ' + hwba[2] + '%' + a + ')';\n};\n\ncs.to.keyword = function (rgb) {\n\treturn reverseNames[rgb.slice(0, 3)];\n};\n\n// helpers\nfunction clamp(num, min, max) {\n\treturn Math.min(Math.max(min, num), max);\n}\n\nfunction hexDouble(num) {\n\tvar str = num.toString(16).toUpperCase();\n\treturn (str.length < 2) ? '0' + str : str;\n}\n","'use strict'\r\n\r\nmodule.exports = {\r\n\t\"aliceblue\": [240, 248, 255],\r\n\t\"antiquewhite\": [250, 235, 215],\r\n\t\"aqua\": [0, 255, 255],\r\n\t\"aquamarine\": [127, 255, 212],\r\n\t\"azure\": [240, 255, 255],\r\n\t\"beige\": [245, 245, 220],\r\n\t\"bisque\": [255, 228, 196],\r\n\t\"black\": [0, 0, 0],\r\n\t\"blanchedalmond\": [255, 235, 205],\r\n\t\"blue\": [0, 0, 255],\r\n\t\"blueviolet\": [138, 43, 226],\r\n\t\"brown\": [165, 42, 42],\r\n\t\"burlywood\": [222, 184, 135],\r\n\t\"cadetblue\": [95, 158, 160],\r\n\t\"chartreuse\": [127, 255, 0],\r\n\t\"chocolate\": [210, 105, 30],\r\n\t\"coral\": [255, 127, 80],\r\n\t\"cornflowerblue\": [100, 149, 237],\r\n\t\"cornsilk\": [255, 248, 220],\r\n\t\"crimson\": [220, 20, 60],\r\n\t\"cyan\": [0, 255, 255],\r\n\t\"darkblue\": [0, 0, 139],\r\n\t\"darkcyan\": [0, 139, 139],\r\n\t\"darkgoldenrod\": [184, 134, 11],\r\n\t\"darkgray\": [169, 169, 169],\r\n\t\"darkgreen\": [0, 100, 0],\r\n\t\"darkgrey\": [169, 169, 169],\r\n\t\"darkkhaki\": [189, 183, 107],\r\n\t\"darkmagenta\": [139, 0, 139],\r\n\t\"darkolivegreen\": [85, 107, 47],\r\n\t\"darkorange\": [255, 140, 0],\r\n\t\"darkorchid\": [153, 50, 204],\r\n\t\"darkred\": [139, 0, 0],\r\n\t\"darksalmon\": [233, 150, 122],\r\n\t\"darkseagreen\": [143, 188, 143],\r\n\t\"darkslateblue\": [72, 61, 139],\r\n\t\"darkslategray\": [47, 79, 79],\r\n\t\"darkslategrey\": [47, 79, 79],\r\n\t\"darkturquoise\": [0, 206, 209],\r\n\t\"darkviolet\": [148, 0, 211],\r\n\t\"deeppink\": [255, 20, 147],\r\n\t\"deepskyblue\": [0, 191, 255],\r\n\t\"dimgray\": [105, 105, 105],\r\n\t\"dimgrey\": [105, 105, 105],\r\n\t\"dodgerblue\": [30, 144, 255],\r\n\t\"firebrick\": [178, 34, 34],\r\n\t\"floralwhite\": [255, 250, 240],\r\n\t\"forestgreen\": [34, 139, 34],\r\n\t\"fuchsia\": [255, 0, 255],\r\n\t\"gainsboro\": [220, 220, 220],\r\n\t\"ghostwhite\": [248, 248, 255],\r\n\t\"gold\": [255, 215, 0],\r\n\t\"goldenrod\": [218, 165, 32],\r\n\t\"gray\": [128, 128, 128],\r\n\t\"green\": [0, 128, 0],\r\n\t\"greenyellow\": [173, 255, 47],\r\n\t\"grey\": [128, 128, 128],\r\n\t\"honeydew\": [240, 255, 240],\r\n\t\"hotpink\": [255, 105, 180],\r\n\t\"indianred\": [205, 92, 92],\r\n\t\"indigo\": [75, 0, 130],\r\n\t\"ivory\": [255, 255, 240],\r\n\t\"khaki\": [240, 230, 140],\r\n\t\"lavender\": [230, 230, 250],\r\n\t\"lavenderblush\": [255, 240, 245],\r\n\t\"lawngreen\": [124, 252, 0],\r\n\t\"lemonchiffon\": [255, 250, 205],\r\n\t\"lightblue\": [173, 216, 230],\r\n\t\"lightcoral\": [240, 128, 128],\r\n\t\"lightcyan\": [224, 255, 255],\r\n\t\"lightgoldenrodyellow\": [250, 250, 210],\r\n\t\"lightgray\": [211, 211, 211],\r\n\t\"lightgreen\": [144, 238, 144],\r\n\t\"lightgrey\": [211, 211, 211],\r\n\t\"lightpink\": [255, 182, 193],\r\n\t\"lightsalmon\": [255, 160, 122],\r\n\t\"lightseagreen\": [32, 178, 170],\r\n\t\"lightskyblue\": [135, 206, 250],\r\n\t\"lightslategray\": [119, 136, 153],\r\n\t\"lightslategrey\": [119, 136, 153],\r\n\t\"lightsteelblue\": [176, 196, 222],\r\n\t\"lightyellow\": [255, 255, 224],\r\n\t\"lime\": [0, 255, 0],\r\n\t\"limegreen\": [50, 205, 50],\r\n\t\"linen\": [250, 240, 230],\r\n\t\"magenta\": [255, 0, 255],\r\n\t\"maroon\": [128, 0, 0],\r\n\t\"mediumaquamarine\": [102, 205, 170],\r\n\t\"mediumblue\": [0, 0, 205],\r\n\t\"mediumorchid\": [186, 85, 211],\r\n\t\"mediumpurple\": [147, 112, 219],\r\n\t\"mediumseagreen\": [60, 179, 113],\r\n\t\"mediumslateblue\": [123, 104, 238],\r\n\t\"mediumspringgreen\": [0, 250, 154],\r\n\t\"mediumturquoise\": [72, 209, 204],\r\n\t\"mediumvioletred\": [199, 21, 133],\r\n\t\"midnightblue\": [25, 25, 112],\r\n\t\"mintcream\": [245, 255, 250],\r\n\t\"mistyrose\": [255, 228, 225],\r\n\t\"moccasin\": [255, 228, 181],\r\n\t\"navajowhite\": [255, 222, 173],\r\n\t\"navy\": [0, 0, 128],\r\n\t\"oldlace\": [253, 245, 230],\r\n\t\"olive\": [128, 128, 0],\r\n\t\"olivedrab\": [107, 142, 35],\r\n\t\"orange\": [255, 165, 0],\r\n\t\"orangered\": [255, 69, 0],\r\n\t\"orchid\": [218, 112, 214],\r\n\t\"palegoldenrod\": [238, 232, 170],\r\n\t\"palegreen\": [152, 251, 152],\r\n\t\"paleturquoise\": [175, 238, 238],\r\n\t\"palevioletred\": [219, 112, 147],\r\n\t\"papayawhip\": [255, 239, 213],\r\n\t\"peachpuff\": [255, 218, 185],\r\n\t\"peru\": [205, 133, 63],\r\n\t\"pink\": [255, 192, 203],\r\n\t\"plum\": [221, 160, 221],\r\n\t\"powderblue\": [176, 224, 230],\r\n\t\"purple\": [128, 0, 128],\r\n\t\"rebeccapurple\": [102, 51, 153],\r\n\t\"red\": [255, 0, 0],\r\n\t\"rosybrown\": [188, 143, 143],\r\n\t\"royalblue\": [65, 105, 225],\r\n\t\"saddlebrown\": [139, 69, 19],\r\n\t\"salmon\": [250, 128, 114],\r\n\t\"sandybrown\": [244, 164, 96],\r\n\t\"seagreen\": [46, 139, 87],\r\n\t\"seashell\": [255, 245, 238],\r\n\t\"sienna\": [160, 82, 45],\r\n\t\"silver\": [192, 192, 192],\r\n\t\"skyblue\": [135, 206, 235],\r\n\t\"slateblue\": [106, 90, 205],\r\n\t\"slategray\": [112, 128, 144],\r\n\t\"slategrey\": [112, 128, 144],\r\n\t\"snow\": [255, 250, 250],\r\n\t\"springgreen\": [0, 255, 127],\r\n\t\"steelblue\": [70, 130, 180],\r\n\t\"tan\": [210, 180, 140],\r\n\t\"teal\": [0, 128, 128],\r\n\t\"thistle\": [216, 191, 216],\r\n\t\"tomato\": [255, 99, 71],\r\n\t\"turquoise\": [64, 224, 208],\r\n\t\"violet\": [238, 130, 238],\r\n\t\"wheat\": [245, 222, 179],\r\n\t\"white\": [255, 255, 255],\r\n\t\"whitesmoke\": [245, 245, 245],\r\n\t\"yellow\": [255, 255, 0],\r\n\t\"yellowgreen\": [154, 205, 50]\r\n};\r\n","'use strict';\n\nvar isArrayish = require('is-arrayish');\n\nvar concat = Array.prototype.concat;\nvar slice = Array.prototype.slice;\n\nvar swizzle = module.exports = function swizzle(args) {\n\tvar results = [];\n\n\tfor (var i = 0, len = args.length; i < len; i++) {\n\t\tvar arg = args[i];\n\n\t\tif (isArrayish(arg)) {\n\t\t\t// http://jsperf.com/javascript-array-concat-vs-push/98\n\t\t\tresults = concat.call(results, slice.call(arg));\n\t\t} else {\n\t\t\tresults.push(arg);\n\t\t}\n\t}\n\n\treturn results;\n};\n\nswizzle.wrap = function (fn) {\n\treturn function () {\n\t\treturn fn(swizzle(arguments));\n\t};\n};\n","module.exports = function isArrayish(obj) {\n\tif (!obj || typeof obj === 'string') {\n\t\treturn false;\n\t}\n\n\treturn obj instanceof Array || Array.isArray(obj) ||\n\t\t(obj.length >= 0 && (obj.splice instanceof Function ||\n\t\t\t(Object.getOwnPropertyDescriptor(obj, (obj.length - 1)) && obj.constructor.name !== 'String')));\n};\n","// parse options from input\n'use strict'\n\nvar boardColor = require('./board-color')\nvar xid = require('@tracespace/xml-id')\nvar xmlElementString = require('xml-element-string')\n\nmodule.exports = function parseOptions(input) {\n if (typeof input === 'string') {\n input = {id: input}\n } else if (!input) {\n input = {}\n }\n\n return {\n id: xid.ensure(input.id),\n color: boardColor.getColor(input.color),\n attributes: input.attributes || {},\n useOutline: input.useOutline != null ? input.useOutline : true,\n createElement: input.createElement || xmlElementString,\n }\n}\n","// sort layers array into top and bottom\n'use strict'\n\nvar wtg = require('whats-that-gerber')\n\nmodule.exports = function sortLayers(layers) {\n return layers.filter(acceptLayer).reduce(assignLayer, {\n top: [],\n bottom: [],\n drills: [],\n outline: null,\n })\n}\n\nfunction acceptLayer(layer) {\n return (\n layer != null &&\n layer.type != null &&\n layer.side != null &&\n layer.converter != null &&\n layer.converter.layer != null &&\n layer.converter.layer.length\n )\n}\n\nfunction assignLayer(result, layer) {\n var type = layer.type\n var side = layer.side\n\n if (type === wtg.TYPE_DRILL) {\n result.drills.push(layer)\n } else if (type === wtg.TYPE_OUTLINE) {\n result.outline = layer\n } else {\n if (side === wtg.SIDE_TOP) {\n result.top.push(layer)\n } else if (side === wtg.SIDE_BOTTOM) {\n result.bottom.push(layer)\n }\n }\n\n return result\n}\n","// stack layers function (where the magic happens)\n'use strict'\n\nvar viewbox = require('viewbox')\nvar wtg = require('whats-that-gerber')\n\nvar gatherLayers = require('./_gather-layers')\n\nmodule.exports = function(\n element,\n id,\n side,\n layers,\n drills,\n outline,\n useOutline,\n copyPads\n) {\n var classPrefix = id + '_'\n var idPrefix = id + '_' + side + '_'\n var mechMaskId = idPrefix + 'mech-mask'\n\n var layerProps = gatherLayers(\n element,\n idPrefix,\n layers,\n drills,\n outline,\n useOutline\n )\n var defs = layerProps.defs\n var box = layerProps.box\n var units = layerProps.units\n\n layers = layerProps.layerIds\n drills = layerProps.drillIds\n\n defs.push(mechMask(element, mechMaskId, box, drills))\n\n // build the layer starting with an fr4 rectangle the size of the viewbox\n var layer = [createRect(element, box, 'currentColor', classPrefix + 'fr4')]\n var copies = []\n var cuLayer = findLayer(layers, wtg.TYPE_COPPER)\n var smLayer = findLayer(layers, wtg.TYPE_SOLDERMASK)\n var ssLayer = findLayer(layers, wtg.TYPE_SILKSCREEN)\n var spLayer = findLayer(layers, wtg.TYPE_SOLDERPASTE)\n var outLayerId = layerProps.outlineId\n\n // add copper and copper finish\n if (cuLayer.id) {\n var cfMaskId = idPrefix + 'cf-mask'\n var cfMaskShape = smLayer.id\n ? [useLayer(element, smLayer.id)]\n : [createRect(element, box)]\n var cfMaskGroupAttr = {fill: '#fff', stroke: '#fff'}\n var cfMaskGroup = [element('g', cfMaskGroupAttr, cfMaskShape)]\n\n defs.push(element('mask', {id: cfMaskId}, cfMaskGroup))\n layer.push(useLayer(element, cuLayer.id, classPrefix + 'cu'))\n layer.push(useLayer(element, cuLayer.id, classPrefix + 'cf', cfMaskId))\n }\n\n // add soldermask and silkscreen\n // silkscreen will not be added if no soldermask, because that's how it works in RL\n if (smLayer.id) {\n // solder mask is... a mask, so mask it\n var smMaskId = idPrefix + 'sm-mask'\n var smMaskShape = [\n createRect(element, box, '#fff'),\n useLayer(element, smLayer.id),\n ]\n var smMaskGroupAtrr = {fill: '#000', stroke: '#000'}\n var smMaskGroup = [element('g', smMaskGroupAtrr, smMaskShape)]\n\n defs.push(element('mask', {id: smMaskId}, smMaskGroup))\n\n // add the layer that gets masked\n var smGroupAttr = {mask: 'url(#' + smMaskId + ')'}\n var smGroupShape = []\n if (!copyPads) {\n smGroupShape.push(createRect(element, box, 'currentColor', classPrefix + 'sm'))\n }\n\n if (ssLayer.id) {\n smGroupShape.push(useLayer(element, ssLayer.id, classPrefix + 'ss'))\n }\n\n layer.push(element('g', smGroupAttr, smGroupShape))\n }\n\n // add solderpaste\n if (spLayer.id) {\n layer.push(useLayer(element, spLayer.id, classPrefix + 'sp'))\n }\n\n // add board outline if necessary\n if (outLayerId && !useOutline) {\n layer.push(useLayer(element, outLayerId, classPrefix + 'out'))\n }\n\n var outline\n if (copyPads) {\n if (smLayer.id) {\n copies.push(smLayer.makeCopy({id: idPrefix + 'sm-copy', fill: 'currentColor', stroke: 'currentColor', class: classPrefix + 'sm'}))\n }\n\n if (spLayer.id) {\n copies.push(spLayer.makeCopy({id: idPrefix + 'sp-copy', fill: 'currentColor', stroke: 'currentColor', class: classPrefix + 'sp'}))\n }\n\n if (layerProps.copyOutline && useOutline) {\n outline = layerProps.copyOutline({id: idPrefix + 'out-copy', fill: 'none', stroke: 'currentColor', class: classPrefix + 'out' + ' ' + 'board-outline'})\n }\n }\n\n return {\n defs: defs,\n layer: layer,\n copies: copies,\n mechMaskId: mechMaskId,\n outClipId: outLayerId && useOutline ? outLayerId : null,\n outline: outline,\n box: box,\n units: units,\n }\n}\n\nfunction findLayer(layers, type) {\n var layer\n var i\n\n for (i = 0; i < layers.length; i++) {\n layer = layers[i]\n if (layer.type === type) {\n return layer\n }\n }\n}\n\nfunction useLayer(element, id, className, mask) {\n var attr = {'xlink:href': '#' + id}\n\n if (className) {\n attr.fill = 'currentColor'\n attr.stroke = 'currentColor'\n attr.class = className\n }\n\n if (mask) {\n attr.mask = 'url(#' + mask + ')'\n }\n\n return element('use', attr)\n}\n\nfunction createRect(element, box, fill, className) {\n var attr = viewbox.rect(box)\n\n if (fill) {\n attr.fill = fill\n }\n\n if (className) {\n attr.class = className\n }\n\n return element('rect', attr)\n}\n\nfunction mechMask(element, id, box, drills) {\n var children = drills.map(function(layer) {\n return useLayer(element, layer.id)\n })\n\n children.unshift(createRect(element, box, '#fff'))\n\n var groupAttr = {fill: '#000', stroke: '#000'}\n var group = [element('g', groupAttr, children)]\n\n return element('mask', {id: id}, group)\n}\n","// helper for stack layers that scales, wraps, gathers the defs of layers\n'use strict'\n\nvar viewbox = require('viewbox')\nvar wtg = require('whats-that-gerber')\n\nvar wrapLayer = require('./wrap-layer')\n\nmodule.exports = function gatherLayers(\n element,\n idPrefix,\n layers,\n drills,\n outline,\n useOutline\n) {\n var defs = []\n var layerIds = []\n var drillIds = []\n var units = ''\n var unitsCount = {in: 0, mm: 0}\n var allLayers = layers.concat(drills, outline || [])\n\n var drillCount = 0\n var getUniqueId = function(type) {\n var id = idPrefix + type\n\n if (type === wtg.TYPE_DRILL) {\n drillCount++\n id += drillCount\n }\n\n return id\n }\n\n allLayers.forEach(function(layer) {\n if (!layer.externalId) {\n defs = defs.concat(layer.converter.defs)\n }\n\n if (layer.converter.units === 'mm') {\n unitsCount.mm++\n } else {\n unitsCount.in++\n }\n })\n\n if (unitsCount.in + unitsCount.mm) {\n units = unitsCount.in > unitsCount.mm ? 'in' : 'mm'\n }\n\n var viewboxLayers = useOutline && outline ? [outline] : allLayers\n\n var box = viewboxLayers.reduce(function(result, layer) {\n var layerBox = layer.converter.viewBox\n var layerUnits = layer.converter.units\n\n if (layerUnits && layerBox[2] !== 0 && layerBox[3] !== 0) {\n return viewbox.add(\n result,\n viewbox.scale(layerBox, getScale(units, layerUnits))\n )\n }\n\n return result\n }, viewbox.create())\n\n var wrapConverterLayer = function(collection) {\n return function(layer) {\n var id = layer.externalId\n var converter = layer.converter\n\n if (!id) {\n id = getUniqueId(layer.type)\n defs.push(\n wrapLayer(element, {id: id}, converter, getScale(units, converter.units))\n )\n }\n\n collection.push({type: layer.type, id: id, makeCopy: function (attr) {\n return wrapLayer(element, attr, converter, getScale(units, converter.units))\n }})\n }\n }\n\n layers.forEach(wrapConverterLayer(layerIds))\n drills.forEach(wrapConverterLayer(drillIds))\n\n var outlineId\n var copyOutline\n\n // add the outline to defs if it's not defined externally or if we're using it to clip\n if (outline) {\n if (outline.externalId && !useOutline) {\n outlineId = outline.externalId\n } else {\n outlineId = getUniqueId(outline.type)\n\n defs.push(\n wrapLayer(\n element,\n {id: outlineId},\n outline.converter,\n getScale(units, outline.converter.units),\n useOutline ? 'clipPath' : 'g'\n )\n )\n\n copyOutline = function (attr) {\n return wrapLayer(element, attr, outline.converter, getScale(units, outline.converter.units))\n }\n }\n }\n\n return {\n defs: defs,\n box: box,\n units: units,\n layerIds: layerIds,\n drillIds: drillIds,\n outlineId: outlineId,\n copyOutline: copyOutline,\n }\n}\n\nfunction getScale(units, layerUnits) {\n var scale = units === 'in' ? 1 / 25.4 : 25.4\n var result = units === layerUnits ? 1 : scale\n\n return result\n}\n","// wrap a layer in a group given the layer's converter object\n'use strict'\n\nmodule.exports = function wrapLayer(element, attr, converter, scale, tag) {\n var layer = converter.layer\n\n if (scale && scale !== 1) {\n attr.transform = 'scale(' + scale + ',' + scale + ')'\n }\n\n return element(tag || 'g', attr, layer)\n}\n","module.exports = `\n\n \n \n \n \n \n \n\n\n\n \n \n \n \n \n \n \n \n \n \n ✓ ✓ \n \n ✗ ✗ \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n`\n","/* global Promise */\n// pcb-stackup main\n'use strict'\n\nvar extend = require('xtend')\nvar runParallel = require('run-parallel')\nvar runWaterfall = require('run-waterfall')\nvar gerberToSvg = require('gerber-to-svg')\nvar createStackup = require('pcb-stackup-core')\nvar wtg = require('whats-that-gerber')\n\nmodule.exports = function pcbStackup(layers, options, done) {\n var result\n\n if (typeof options === 'function') {\n done = options\n options = null\n }\n\n validateLayersInput(layers)\n\n // promise mode\n if (done == null) {\n if (typeof Promise !== 'function') {\n throw new Error('No callback specified and global Promise not found')\n }\n\n result = new Promise(function(resolve, reject) {\n done = function callbackToPromise(error, stackup) {\n if (error) return reject(error)\n resolve(stackup)\n }\n })\n }\n\n var layerTypes = wtg(\n layers\n .map(function(layer) {\n return layer.filename\n })\n .filter(Boolean)\n )\n\n runWaterfall(\n [\n // render all layers with gerber-to-svg in parallel\n function renderAllLayers(next) {\n var layerTasks = layers.map(makeRenderLayerTask)\n runParallel(layerTasks, next)\n },\n // using the result of renderAllLayers, build the stackup\n function renderStackup(stackupLayers, next) {\n var stackup = createStackup(stackupLayers, options)\n stackup.layers = stackupLayers\n next(null, stackup)\n },\n ],\n function finish(error, stackup) {\n // ensure only error is passed if it exists\n if (error) return done(error)\n done(null, stackup)\n }\n )\n\n // if in Promise mode, return the Promise\n return result\n\n // map an pcb-stackup input layer into a function that will call a callback\n // once a pcb-stackup-core input layer is ready\n function makeRenderLayerTask(layer) {\n return function renderLayer(next) {\n var stackupLayer = makeBaseStackupLayer(layer)\n\n if (stackupLayer.converter) return next(null, stackupLayer)\n\n var converter = gerberToSvg(\n stackupLayer.gerber,\n stackupLayer.options,\n function handleLayerDone(error) {\n if (error) return next(error)\n stackupLayer.converter = converter\n next(null, stackupLayer)\n }\n )\n }\n }\n\n // extend pcb-stackup input layer with necessary details for pcb-stackup-core\n function makeBaseStackupLayer(layer) {\n var layerSide = layer.side\n var layerType = layer.type\n\n if (\n layer.filename &&\n typeof layerSide === 'undefined' &&\n typeof layerType === 'undefined'\n ) {\n var gerberId = layerTypes[layer.filename]\n layerSide = gerberId.side\n layerType = gerberId.type\n }\n\n var layerOptions = extend(layer.options)\n\n if (layerOptions.plotAsOutline == null && layerType === wtg.TYPE_OUTLINE) {\n layerOptions.plotAsOutline = true\n }\n\n if (\n options &&\n options.outlineGapFill != null &&\n layerOptions.plotAsOutline\n ) {\n layerOptions.plotAsOutline = options.outlineGapFill\n }\n\n return extend(layer, {\n side: layerSide,\n type: layerType,\n options: layerOptions,\n })\n }\n}\n\nfunction validateLayersInput(layers) {\n if (!Array.isArray(layers)) {\n throw new Error('first argument should be an array of layers')\n }\n\n var layerErrors = layers\n .map(getLayerValidationError)\n .filter(Boolean)\n .join(', ')\n\n if (layerErrors) throw new Error(layerErrors)\n}\n\nfunction getLayerValidationError(layer, index) {\n var result = wtg.validate(layer)\n var error = null\n\n if (!layer.converter && !layer.gerber) {\n error = 'is missing gerber source or cached converter'\n } else if (!layer.filename && !layer.type) {\n error = 'is missing filename or side/type'\n } else if (!layer.filename && !result.valid) {\n error = 'has invalid side/type (' + layer.side + '/' + layer.type + ')'\n }\n\n return error ? 'layer ' + index + ' ' + error : null\n}\n"],"sourceRoot":""}