diff --git a/arkoala-arkts/arkui/src/generated/peers/ArkUINodeType.ts b/arkoala-arkts/arkui/src/generated/peers/ArkUINodeType.ts index c671e96ad64dd28a33fc885503ad15506c193c0a..de59645e62e010b67bc4af9f4deb9803d210a664 100644 --- a/arkoala-arkts/arkui/src/generated/peers/ArkUINodeType.ts +++ b/arkoala-arkts/arkui/src/generated/peers/ArkUINodeType.ts @@ -2,36 +2,117 @@ export enum ArkUINodeType { Root, ComponentRoot, CustomNode, + AbilityComponent, + AlphabetIndexer, + Animator, + Badge, + BaseSpan, Blank, Button, + Calendar, CalendarPicker, Canvas, + Checkbox, + CheckboxGroup, + Circle, Column, + ColumnSplit, Common, CommonMethod, CommonShapeMethod, + Component3D, + ContainerSpan, + Counter, + DataPanel, + DatePicker, + Divider, + EffectComponent, + Ellipse, EmbeddedComponent, + Flex, + FlowItem, + FolderStack, FormComponent, + FormLink, + Gauge, + Grid, + GridCol, GridContainer, + GridItem, + GridRow, + Hyperlink, Image, + ImageAnimator, + ImageSpan, + Line, + LinearIndicator, List, + ListItem, + ListItemGroup, + LoadingProgress, + LocationButton, + Marquee, + MediaCachedImage, + Menu, + MenuItem, + MenuItemGroup, NavDestination, + NavRouter, Navigation, + Navigator, + NodeContainer, + Panel, + PasteButton, + Path, + PatternLock, + PluginComponent, + Polygon, + Polyline, + Progress, + QRCode, + Radio, + Rating, Rect, + Refresh, + RelativeContainer, + RemoteWindow, + RichEditor, + RichText, + RootScene, + Row, + RowSplit, + SaveButton, + Screen, Scroll, + ScrollBar, ScrollableCommonMethod, + Search, + SecurityComponentMethod, Select, Shape, SideBarContainer, + Slider, + Span, + Stack, + Stepper, + StepperItem, Swiper, SymbolGlyph, + SymbolSpan, TabContent, Tabs, - Test, Text, + TextArea, + TextClock, TextInput, TextPicker, + TextTimer, + TimePicker, + Toggle, UIExtensionComponent, - Vector, + Video, + WaterFlow, Web, + WindowScene, + XComponent, } \ No newline at end of file diff --git a/arkoala-arkts/framework/arktsconfig-unmemoized-entry.json b/arkoala-arkts/framework/arktsconfig-unmemoized-entry.json index 902434e876a089cf7e51fd10aac1129e9dec03e6..bba7c0d3ea9ae76b3a409e198d6a692774a74896 100644 --- a/arkoala-arkts/framework/arktsconfig-unmemoized-entry.json +++ b/arkoala-arkts/framework/arktsconfig-unmemoized-entry.json @@ -29,7 +29,6 @@ "#arkcompat": [ "../../arkoala/arkui-common/src" ] - } }, diff --git a/arkoala-arkts/framework/package.json b/arkoala-arkts/framework/package.json index e3084b594abd822d883cdb0333cc7a84aa1b1991..12f52c7abe5b87ab18f6161ae13a437c19f2607f 100644 --- a/arkoala-arkts/framework/package.json +++ b/arkoala-arkts/framework/package.json @@ -7,7 +7,7 @@ "compile:arkts:unmemoized:entry": "npm run unmemoize0 && bash ../../incremental/tools/panda/arkts/arktsc --arktsconfig arktsconfig-unmemoized-entry.json", "compile:ts": "memo-tsc -b ./tsconfig.json", "link:arkui": "cd ../arkui && npm run link:arkui", - "link:framework": "npm run link:arkui && npm run compile:arkts:unmemoized && npm run compile:arkts:unmemoized:entry && bash ../../incremental/tools/panda/arkts/arklink --output build/arkoala.abc -- ../arkui/build/arkui.abc $(find build/abc -name '*.abc' ! -name 'index.abc')", + "link:framework": "npm run link:arkui && npm run compile:arkts:unmemoized:entry && bash ../../incremental/tools/panda/arkts/arklink --output build/arkoala.abc -- ../arkui/build/arkui.abc $(find build/abc -name '*.abc' ! -name 'index.abc')", "unmemoize0": "rm -rf unmemoized && mkdir unmemoized && cp -r src unmemoized/ # No real unmemoization needed for peers" } diff --git a/arkoala-arkts/framework/src/Application.sts b/arkoala-arkts/framework/src/Application.sts index df90475c11b681f8268639998d57d4aebfe4fc61..f77536ab7016bea9f5eb650da4d31fe6e1d80a84 100644 --- a/arkoala-arkts/framework/src/Application.sts +++ b/arkoala-arkts/framework/src/Application.sts @@ -18,7 +18,7 @@ import { int32, int8Array } from "@koalaui/common" import { ArkUINodeType, PeerNode } from "@koalaui/arkts-arkui" import { nativeModule } from "@koalaui/arkts-arkui" import { nullptr } from "@koalaui/interop" -import { Page } from "./Page" +import { PageIndex } from "./Page" export function checkEvents() { customEventsChecker() @@ -80,8 +80,7 @@ function createMemoRoot(manager: StateManager): ComputableState { const node = manager.updatableNode(peer, (context: StateContext) => { const frozen = manager.frozen manager.frozen = true - //Page(rootPointer!) - Page(peer) + PageIndex(peer) // call memoEntry manager.frozen = frozen }) diff --git a/arkoala-arkts/framework/src/Page.ts b/arkoala-arkts/framework/src/Page.ts index e16026b586a3a5b7432f37092e99b02fa1924c13..e501136f8df7384d7b1123ee70a97c56da76438e 100644 --- a/arkoala-arkts/framework/src/Page.ts +++ b/arkoala-arkts/framework/src/Page.ts @@ -1,61 +1,3 @@ -import { int32, int8Array } from "@koalaui/compat" -import { ArkUINodeType, ArkButtonPeer, ArkColumnPeer, NativePeerNode, PeerNode } from "@koalaui/arkts-arkui" -import { nativeModule } from "#components" - -export function startNativeLog(group: int32) { - nativeModule()._StartGroupedLog(group) -} - -export function stopNativeLog(group: int32) { - nativeModule()._StopGroupedLog(group) -} - -export function getNativeLog(group: int32): string { - let ptr = nativeModule()._GetGroupedLog(group) - let length = nativeModule()._StringLength(ptr) - let data = int8Array(length); - nativeModule()._StringData(ptr, data, length) - nativeModule()._InvokeFinalizer(ptr, nativeModule()._GetStringFinalizer()) - // TODO: better string decoding. - let result = "NativeLog..." - for (let i = 0; i < length; i++) { - result += String.fromCharCode(data[i]) - } - return result.toString() -} - -/** @memo */ -export function Page(root: PeerNode) { - startNativeLog(1) - - const rPeer = root.peer - const rPtr = root.peer.ptr - - const componentRoot = new PeerNode(ArkUINodeType.ComponentRoot, 0, "ComponentRoot") - const column = ArkColumnPeer.create(ArkUINodeType.Column) - - // column.widthAttribute(300) - // column.heightAttribute(300) - - const button = ArkButtonPeer.create(ArkUINodeType.Button) - - // button.widthAttribute("250px") - // button.heightAttribute("250px") - - root.peer.addChild(componentRoot.peer) - componentRoot.peer.addChild(column.peer) - column.peer.addChild(button.peer) - - // root.peer.dumpTree() - - nativeModule()._MeasureLayoutAndDraw(root.peer.ptr) - - //nativeModule()._ApplyModifierFinish(root.peer.prt) - nativeModule()._ApplyModifierFinish(rPtr) - nativeModule()._ApplyModifierFinish(componentRoot.peer.ptr) - nativeModule()._ApplyModifierFinish(column.peer.ptr) - nativeModule()._ApplyModifierFinish(button.peer.ptr) - - stopNativeLog(1) - console.log(getNativeLog(1)) -} +// fake entry point +import { PeerNode } from "@koalaui/arkts-arkui" +export function PageIndex(root: PeerNode){} diff --git a/arkoala-arkts/har/arkoala-har-bundle/loader.js b/arkoala-arkts/har/arkoala-har-bundle/loader.js index 8dcfb9da9b9a34ecb2741f0674798a4c9838cca1..0e3c69df67515eed0947457f2455b32d247b010b 100644 --- a/arkoala-arkts/har/arkoala-har-bundle/loader.js +++ b/arkoala-arkts/har/arkoala-har-bundle/loader.js @@ -117,7 +117,7 @@ export function checkLoader(variant) { } let result = nativeModule()._LoadVirtualMachine(vm, classPath, nativePath); if (result == 0) { - rootPointer = nativeModule()._StartApplication(); + rootPointer = nativeModule()._StartApplication("ArkTSLoaderApp", "ArkTSLoaderParam"); setTimeout(async () => runEventLoop(), 0); } else { diff --git a/arkoala-arkts/loader/src/EntryInterface.ts b/arkoala-arkts/loader/src/EntryInterface.ts new file mode 100644 index 0000000000000000000000000000000000000000..e70c598180932b5a29565c19601ff4ec7ce87d62 --- /dev/null +++ b/arkoala-arkts/loader/src/EntryInterface.ts @@ -0,0 +1,3 @@ +interface UserInterface { + entryUrl: string +} \ No newline at end of file diff --git a/arkoala-arkts/loader/src/loader.ts b/arkoala-arkts/loader/src/loader.ts index 520c9b0050f1ea96178942e638a27c98d524754d..dd0110480b9ac3357a532eafba0a178e1aa1a978 100644 --- a/arkoala-arkts/loader/src/loader.ts +++ b/arkoala-arkts/loader/src/loader.ts @@ -158,6 +158,7 @@ export function checkLoader(): int32 { const result = nativeModule()._LoadVirtualMachine(vmKind, classPath, nativePath) if (result == 0) { + // how to get urls? rootPointer = nativeModule()._StartApplication("ArkTSLoaderApp", "ArkTSLoaderParam"); setTimeout(async () => runEventLoop(), 0) } else { diff --git a/arkoala-arkts/user/Page.ts b/arkoala-arkts/user/Page.ts new file mode 100644 index 0000000000000000000000000000000000000000..6bb6b720ab98212632677317a38570b856f7bc24 --- /dev/null +++ b/arkoala-arkts/user/Page.ts @@ -0,0 +1,56 @@ +import { int32, int8Array } from "@koalaui/compat" +import { ArkUINodeType, ArkButtonPeer, ArkColumnPeer, NativePeerNode, PeerNode } from "@koalaui/arkts-arkui" +import { nativeModule } from "#components" + +export function startNativeLog(group: int32) { + nativeModule()._StartGroupedLog(group) +} + +export function stopNativeLog(group: int32) { + nativeModule()._StopGroupedLog(group) +} + +export function getNativeLog(group: int32): string { + let ptr = nativeModule()._GetGroupedLog(group) + let length = nativeModule()._StringLength(ptr) + let data = int8Array(length); + nativeModule()._StringData(ptr, data, length) + nativeModule()._InvokeFinalizer(ptr, nativeModule()._GetStringFinalizer()) + // TODO: better string decoding. + let result = "NativeLog..." + for (let i = 0; i < length; i++) { + result += String.fromCharCode(data[i]) + } + return result.toString() +} + +/** @memo */ +export function PageIndex(root: PeerNode) { + startNativeLog(1) + + const componentRoot = new PeerNode(ArkUINodeType.ComponentRoot, 0, "ComponentRoot") + const column = ArkColumnPeer.create(ArkUINodeType.Column) + + // column.widthAttribute("300px") + // column.heightAttribute("300px") + + const button = ArkButtonPeer.create(ArkUINodeType.Button) + + // button.widthAttribute("250px") + // button.heightAttribute("250px") + + componentRoot.peer.insertChildAfter(column.peer, undefined) + column.peer.insertChildAfter(button.peer, undefined) + + // root.peer.dumpTree() + + nativeModule()._MeasureLayoutAndDraw(root.peer.ptr) + + nativeModule()._ApplyModifierFinish(root.peer.ptr) + nativeModule()._ApplyModifierFinish(componentRoot.peer.ptr) + nativeModule()._ApplyModifierFinish(column.peer.ptr) + nativeModule()._ApplyModifierFinish(button.peer.ptr) + + stopNativeLog(1) + console.log(getNativeLog(1)) +} diff --git a/arkoala-arkts/user/app/.gitignore b/arkoala-arkts/user/app/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..ad2fbb06ea567bc922064bc7049dc2f92f0310cd --- /dev/null +++ b/arkoala-arkts/user/app/.gitignore @@ -0,0 +1,11 @@ +.hvigor +node_modules +oh_modules +rawfile +libs +generated +test.log +test-images +build* +!build-profile.json5 +ohpm diff --git a/arkoala-arkts/user/app/AppScope/app.json5 b/arkoala-arkts/user/app/AppScope/app.json5 new file mode 100644 index 0000000000000000000000000000000000000000..941642c557e48d22670d316cb45ea92414ac92dd --- /dev/null +++ b/arkoala-arkts/user/app/AppScope/app.json5 @@ -0,0 +1,10 @@ +{ + "app": { + "bundleName": "com.example.user", + "vendor": "example", + "versionCode": 1000000, + "versionName": "1.0.0", + "icon": "$media:app_icon", + "label": "$string:app_name" + } +} diff --git a/arkoala-arkts/user/app/build-profile.json5 b/arkoala-arkts/user/app/build-profile.json5 new file mode 100644 index 0000000000000000000000000000000000000000..2ee625f46f9040da1757d80ebc950a886012849b --- /dev/null +++ b/arkoala-arkts/user/app/build-profile.json5 @@ -0,0 +1,28 @@ +{ + "app": { + "signingConfigs": [], + "products": [ + { + "name": "default", + "signingConfig": "default", + "compileSdkVersion": "5.0.0(12)", + "compatibleSdkVersion": "5.0.0(12)", + "runtimeOS": "HarmonyOS", + } + ], + "buildModeSet": [ + { + "name": "debug", + }, + { + "name": "release" + } + ] + }, + "modules": [ + { + "name": "user", + "srcPath": "./user" + } + ] +} \ No newline at end of file diff --git a/arkoala-arkts/user/app/hvigor/hvigor-config.json5 b/arkoala-arkts/user/app/hvigor/hvigor-config.json5 new file mode 100644 index 0000000000000000000000000000000000000000..792dd237449ebb23683ff3c9021626ddaa9d0a23 --- /dev/null +++ b/arkoala-arkts/user/app/hvigor/hvigor-config.json5 @@ -0,0 +1,22 @@ +{ + "modelVersion": "5.0.0", + "dependencies": { + }, + "execution": { + // "analyze": "default", /* Define the build analyze mode. Value: [ "default" | "verbose" | false ]. Default: "default" */ + // "daemon": true, /* Enable daemon compilation. Value: [ true | false ]. Default: true */ + // "incremental": true, /* Enable incremental compilation. Value: [ true | false ]. Default: true */ + // "parallel": true, /* Enable parallel compilation. Value: [ true | false ]. Default: true */ + // "typeCheck": false, /* Enable typeCheck. Value: [ true | false ]. Default: false */ + }, + "logging": { + // "level": "info" /* Define the log level. Value: [ "debug" | "info" | "warn" | "error" ]. Default: "info" */ + }, + "debugging": { + // "stacktrace": false /* Disable stacktrace compilation. Value: [ true | false ]. Default: false */ + }, + "nodeOptions": { + // "maxOldSpaceSize": 4096 /* Enable nodeOptions maxOldSpaceSize compilation. Unit M. Used for the daemon process */ + } +} + diff --git a/arkoala-arkts/user/app/hvigorfile.ts b/arkoala-arkts/user/app/hvigorfile.ts new file mode 100644 index 0000000000000000000000000000000000000000..f3cb9f1a87a81687554a76283af8df27d8bda775 --- /dev/null +++ b/arkoala-arkts/user/app/hvigorfile.ts @@ -0,0 +1,6 @@ +import { appTasks } from '@ohos/hvigor-ohos-plugin'; + +export default { + system: appTasks, /* Built-in plugin of Hvigor. It cannot be modified. */ + plugins:[] /* Custom plugin to extend the functionality of Hvigor. */ +} diff --git a/arkoala-arkts/user/app/oh-package-lock.json5 b/arkoala-arkts/user/app/oh-package-lock.json5 new file mode 100644 index 0000000000000000000000000000000000000000..eb49e703772294ed405164fa05718169295449a0 --- /dev/null +++ b/arkoala-arkts/user/app/oh-package-lock.json5 @@ -0,0 +1,18 @@ +{ + "lockfileVersion": 1, + "ATTENTION": "THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.", + "specifiers": { + "@ohos/hamock@1.0.0-rc": "@ohos/hamock@1.0.0-rc", + "@ohos/hypium@1.0.15": "@ohos/hypium@1.0.15" + }, + "packages": { + "@ohos/hamock@1.0.0-rc": { + "resolved": "https://cmc.centralrepo.rnd.huawei.com/artifactory/api/npm/product_npm/@ohos/hamock/-/@ohos/hamock-1.0.0-rc.tgz", + "integrity": "sha512-98k5LGfWtJ98fjYT9ERBNZSBXFCPNBFf98AjAqhrQ2vtAQuB5MZaf890/Yz+HbBVELtFaSU8H+SyEnb+3MYQwg==" + }, + "@ohos/hypium@1.0.15": { + "resolved": "https://cmc.centralrepo.rnd.huawei.com/artifactory/api/npm/product_npm/@ohos/hypium/-/@ohos/hypium-1.0.15.tgz", + "integrity": "sha512-iUXzaa6ygUe208FxKQvv07ef9NxWSiqYnw8ApFGJVLMWzo4qpevweclWINvumQYRDaQzdAgzzWHzYoFm5vGFEA==" + } + } +} \ No newline at end of file diff --git a/arkoala-arkts/user/app/oh-package.json5 b/arkoala-arkts/user/app/oh-package.json5 new file mode 100644 index 0000000000000000000000000000000000000000..332c838bbbbb8c7f14b9487b1744f6f0aebbd16a --- /dev/null +++ b/arkoala-arkts/user/app/oh-package.json5 @@ -0,0 +1,13 @@ +{ + "modelVersion": "5.0.0", + "name": "@koalaui/user", + "version": "1.0.0", + "description": "Please describe the basic information.", + "main": "", + "author": "", + "license": "", + "dependencies": { + }, + "devDependencies": { + } +} diff --git a/arkoala-arkts/user/app/user/BuildProfile.ets b/arkoala-arkts/user/app/user/BuildProfile.ets new file mode 100644 index 0000000000000000000000000000000000000000..3a501e5ddee8ea6d28961648fc7dd314a5304bd4 --- /dev/null +++ b/arkoala-arkts/user/app/user/BuildProfile.ets @@ -0,0 +1,17 @@ +/** + * Use these variables when you tailor your ArkTS code. They must be of the const type. + */ +export const HAR_VERSION = '1.0.0'; +export const BUILD_MODE_NAME = 'debug'; +export const DEBUG = true; +export const TARGET_NAME = 'default'; + +/** + * BuildProfile Class is used only for compatibility purposes. + */ +export default class BuildProfile { + static readonly HAR_VERSION = HAR_VERSION; + static readonly BUILD_MODE_NAME = BUILD_MODE_NAME; + static readonly DEBUG = DEBUG; + static readonly TARGET_NAME = TARGET_NAME; +} \ No newline at end of file diff --git a/arkoala-arkts/user/app/user/build-profile.json5 b/arkoala-arkts/user/app/user/build-profile.json5 new file mode 100644 index 0000000000000000000000000000000000000000..312d38eb08629793b3484c7373213f22840c8d82 --- /dev/null +++ b/arkoala-arkts/user/app/user/build-profile.json5 @@ -0,0 +1,28 @@ +{ + "apiType": "stageMode", + "buildOption": { + }, + "buildOptionSet": [ + { + "name": "release", + "arkOptions": { + "obfuscation": { + "ruleOptions": { + "enable": true, + "files": [ + "./obfuscation-rules.txt" + ] + }, + "consumerFiles": [ + "./consumer-rules.txt" + ] + } + }, + }, + ], + "targets": [ + { + "name": "default" + } + ] +} diff --git a/arkoala-arkts/user/app/user/consumer-rules.txt b/arkoala-arkts/user/app/user/consumer-rules.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/arkoala-arkts/user/app/user/hvigorfile.ts b/arkoala-arkts/user/app/user/hvigorfile.ts new file mode 100644 index 0000000000000000000000000000000000000000..42187071482d292588ad40babeda74f7b8d97a23 --- /dev/null +++ b/arkoala-arkts/user/app/user/hvigorfile.ts @@ -0,0 +1,6 @@ +import { harTasks } from '@ohos/hvigor-ohos-plugin'; + +export default { + system: harTasks, /* Built-in plugin of Hvigor. It cannot be modified. */ + plugins:[] /* Custom plugin to extend the functionality of Hvigor. */ +} diff --git a/arkoala-arkts/user/app/user/obfuscation-rules.txt b/arkoala-arkts/user/app/user/obfuscation-rules.txt new file mode 100644 index 0000000000000000000000000000000000000000..985b2aeb7658286b17bd26eab8f217c3fe75ea8b --- /dev/null +++ b/arkoala-arkts/user/app/user/obfuscation-rules.txt @@ -0,0 +1,18 @@ +# Define project specific obfuscation rules here. +# You can include the obfuscation configuration files in the current module's build-profile.json5. +# +# For more details, see +# https://gitee.com/openharmony/arkcompiler_ets_frontend/blob/master/arkguard/README.md + +# Obfuscation options: +# -disable-obfuscation: disable all obfuscations +# -enable-property-obfuscation: obfuscate the property names +# -enable-toplevel-obfuscation: obfuscate the names in the global scope +# -compact: remove unnecessary blank spaces and all line feeds +# -remove-log: remove all console.* statements +# -print-namecache: print the name cache that contains the mapping from the old names to new names +# -apply-namecache: reuse the given cache file + +# Keep options: +# -keep-property-name: specifies property names that you want to keep +# -keep-global-name: specifies names that you want to keep in the global scope \ No newline at end of file diff --git a/arkoala-arkts/user/app/user/oh-package.json5 b/arkoala-arkts/user/app/user/oh-package.json5 new file mode 100644 index 0000000000000000000000000000000000000000..d2aec4670d801c545bcbcb564155632112f7e070 --- /dev/null +++ b/arkoala-arkts/user/app/user/oh-package.json5 @@ -0,0 +1,10 @@ +{ + "name": "@koalaui/user", + "version": "1.0.0", + "description": "Please describe the basic information.", + "main": "", + "types": "", + "author": "", + "license": "Apache-2.0", + "dependencies": {} +} diff --git a/arkoala-arkts/user/app/user/src/main/module.json5 b/arkoala-arkts/user/app/user/src/main/module.json5 new file mode 100644 index 0000000000000000000000000000000000000000..6b0ad6685ad208707f810b65f66cbd88ff98e833 --- /dev/null +++ b/arkoala-arkts/user/app/user/src/main/module.json5 @@ -0,0 +1,11 @@ +{ + "module": { + "name": "user", + "type": "har", + "deviceTypes": [ + "default", + "tablet", + "2in1" + ] + } +} diff --git a/arkoala-arkts/framework/arktsconfig-unmemoized.json b/arkoala-arkts/user/arktsconfig-unmemoized.json similarity index 96% rename from arkoala-arkts/framework/arktsconfig-unmemoized.json rename to arkoala-arkts/user/arktsconfig-unmemoized.json index ec7678285c863db941bd3dd23fde1aceecd338be..cb1c56e01ce34632be7bdff50f73ff59194437e0 100644 --- a/arkoala-arkts/framework/arktsconfig-unmemoized.json +++ b/arkoala-arkts/user/arktsconfig-unmemoized.json @@ -33,5 +33,5 @@ } }, - "include": ["./src/Page.ts"] + "include": ["./Page.ts"] } diff --git a/arkoala-arkts/user/command-line-tools/hvigor/bin/hvigorw b/arkoala-arkts/user/command-line-tools/hvigor/bin/hvigorw new file mode 100755 index 0000000000000000000000000000000000000000..0f7974ffd18fe19033a61734312083a2fae138a3 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/bin/hvigorw @@ -0,0 +1,54 @@ +#!/usr/bin/env bash + +# ---------------------------------------------------------------------------- +# Hvigor startup script, version 1.0.0 +# +# Required ENV vars: +# ------------------ +# NODE_HOME - location of a Node home dir +# or +# Add /usr/local/nodejs/bin to the PATH environment variable +# ---------------------------------------------------------------------------- + +HVIGOR_APP_HOME="$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")" +HVIGOR_WRAPPER_SCRIPT=${HVIGOR_APP_HOME}/hvigorw.js +#NODE_OPTS="--max-old-space-size=8192 --expose-gc" + +warn() { + echo "" + echo -e "\033[1;33m`date '+[%Y-%m-%d %H:%M:%S]'`$@\033[0m" +} + +error() { + echo "" + echo -e "\033[1;31m`date '+[%Y-%m-%d %H:%M:%S]'`$@\033[0m" +} + +fail() { + error "$@" + exit 1 +} + +# Determine node to start hvigor wrapper script +if [ -n "${NODE_HOME}" ];then + EXECUTABLE_NODE="${NODE_HOME}/bin/node" + if [ ! -x "$EXECUTABLE_NODE" ];then + fail "ERROR: NODE_HOME is set to an invalid directory,check $NODE_HOME\n\nPlease set NODE_HOME in your environment to the location where your nodejs installed" + fi +else + EXECUTABLE_NODE="node" + which ${EXECUTABLE_NODE} > /dev/null 2>&1 || fail "ERROR: NODE_HOME is not set and not 'node' command found in your path" +fi + +# Check hvigor wrapper script +if [ ! -r "$HVIGOR_WRAPPER_SCRIPT" ];then + fail "ERROR: Couldn't find hvigorw.js in ${HVIGOR_APP_HOME}" +fi + +if [ -z "${NODE_OPTS}" ]; then + NODE_OPTS="--" +fi + +# start hvigor-wrapper script +exec "${EXECUTABLE_NODE}" "${NODE_OPTS}" \ + "${HVIGOR_WRAPPER_SCRIPT}" "$@" diff --git a/arkoala-arkts/user/command-line-tools/hvigor/bin/hvigorw.bat b/arkoala-arkts/user/command-line-tools/hvigor/bin/hvigorw.bat new file mode 100755 index 0000000000000000000000000000000000000000..1c1cc00659b3744afb0bb267bc9034f2a5dae099 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/bin/hvigorw.bat @@ -0,0 +1,67 @@ +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Hvigor startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +set WRAPPER_MODULE_PATH=%DIRNAME%\hvigorw.js +set NODE_EXE=node.exe +@rem set NODE_OPTS="--max-old-space-size=8192 --expose-gc" + +goto start + +:start +if not defined NODE_OPTS set NODE_OPTS="--" + +@rem Find node.exe +if defined NODE_HOME goto findNodeFromNodeHome + +%NODE_EXE% --version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: NODE_HOME is not set and no 'node' command could be found in your PATH. +echo. +echo Please set the NODE_HOME variable in your environment to match the +echo location of your NodeJs installation. + +goto fail + +:findNodeFromNodeHome +set NODE_HOME=%NODE_HOME:"=% +set NODE_EXE_PATH=%NODE_HOME%/%NODE_EXE% + +if exist "%NODE_EXE_PATH%" goto execute +echo. +echo ERROR: NODE_HOME is not set and no 'node' command could be found in your PATH. +echo. +echo Please set the NODE_HOME variable in your environment to match the +echo location of your NodeJs installation. + +goto fail + +:execute +@rem Execute hvigor +"%NODE_EXE%" "%NODE_OPTS%" "%WRAPPER_MODULE_PATH%" %* + +if "%ERRORLEVEL%" == "0" goto hvigorwEnd + +:fail +exit /b 1 + +:hvigorwEnd +if "%OS%" == "Windows_NT" endlocal + +:end diff --git a/arkoala-arkts/user/command-line-tools/hvigor/bin/hvigorw.js b/arkoala-arkts/user/command-line-tools/hvigor/bin/hvigorw.js new file mode 100755 index 0000000000000000000000000000000000000000..d798b66c984a03ab8e5d158940856bc51a59c0e6 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/bin/hvigorw.js @@ -0,0 +1,9229 @@ +"use strict"; + +var e = require("fs"), t = require("path"), r = require("process"), n = require("os"), i = require("child_process"), o = require("constants"), s = require("stream"), u = require("util"), a = require("assert"), c = require("tty"), l = require("url"), f = require("zlib"), d = require("net"), p = require("fs/promises"), h = require("crypto"), E = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof self ? self : {}, D = { + exports: {} +}; + +var m = { + MAX_LENGTH: 256, + MAX_SAFE_COMPONENT_LENGTH: 16, + MAX_SAFE_BUILD_LENGTH: 250, + MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER || 9007199254740991, + RELEASE_TYPES: [ "major", "premajor", "minor", "preminor", "patch", "prepatch", "prerelease" ], + SEMVER_SPEC_VERSION: "2.0.0", + FLAG_INCLUDE_PRERELEASE: 1, + FLAG_LOOSE: 2 +}; + +var g = "object" == typeof process && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...e) => console.error("SEMVER", ...e) : () => {}; + +!function(e, t) { + const {MAX_SAFE_COMPONENT_LENGTH: r, MAX_SAFE_BUILD_LENGTH: n, MAX_LENGTH: i} = m, o = g, s = (t = e.exports = {}).re = [], u = t.safeRe = [], a = t.src = [], c = t.t = {}; + let l = 0; + const f = "[a-zA-Z0-9-]", d = [ [ "\\s", 1 ], [ "\\d", i ], [ f, n ] ], p = (e, t, r) => { + const n = (e => { + for (const [t, r] of d) { + e = e.split(`${t}*`).join(`${t}{0,${r}}`).split(`${t}+`).join(`${t}{1,${r}}`); + } + return e; + })(t), i = l++; + o(e, i, t), c[e] = i, a[i] = t, s[i] = new RegExp(t, r ? "g" : void 0), u[i] = new RegExp(n, r ? "g" : void 0); + }; + p("NUMERICIDENTIFIER", "0|[1-9]\\d*"), p("NUMERICIDENTIFIERLOOSE", "\\d+"), p("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${f}*`), + p("MAINVERSION", `(${a[c.NUMERICIDENTIFIER]})\\.(${a[c.NUMERICIDENTIFIER]})\\.(${a[c.NUMERICIDENTIFIER]})`), + p("MAINVERSIONLOOSE", `(${a[c.NUMERICIDENTIFIERLOOSE]})\\.(${a[c.NUMERICIDENTIFIERLOOSE]})\\.(${a[c.NUMERICIDENTIFIERLOOSE]})`), + p("PRERELEASEIDENTIFIER", `(?:${a[c.NUMERICIDENTIFIER]}|${a[c.NONNUMERICIDENTIFIER]})`), + p("PRERELEASEIDENTIFIERLOOSE", `(?:${a[c.NUMERICIDENTIFIERLOOSE]}|${a[c.NONNUMERICIDENTIFIER]})`), + p("PRERELEASE", `(?:-(${a[c.PRERELEASEIDENTIFIER]}(?:\\.${a[c.PRERELEASEIDENTIFIER]})*))`), + p("PRERELEASELOOSE", `(?:-?(${a[c.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${a[c.PRERELEASEIDENTIFIERLOOSE]})*))`), + p("BUILDIDENTIFIER", `${f}+`), p("BUILD", `(?:\\+(${a[c.BUILDIDENTIFIER]}(?:\\.${a[c.BUILDIDENTIFIER]})*))`), + p("FULLPLAIN", `v?${a[c.MAINVERSION]}${a[c.PRERELEASE]}?${a[c.BUILD]}?`), p("FULL", `^${a[c.FULLPLAIN]}$`), + p("LOOSEPLAIN", `[v=\\s]*${a[c.MAINVERSIONLOOSE]}${a[c.PRERELEASELOOSE]}?${a[c.BUILD]}?`), + p("LOOSE", `^${a[c.LOOSEPLAIN]}$`), p("GTLT", "((?:<|>)?=?)"), p("XRANGEIDENTIFIERLOOSE", `${a[c.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), + p("XRANGEIDENTIFIER", `${a[c.NUMERICIDENTIFIER]}|x|X|\\*`), p("XRANGEPLAIN", `[v=\\s]*(${a[c.XRANGEIDENTIFIER]})(?:\\.(${a[c.XRANGEIDENTIFIER]})(?:\\.(${a[c.XRANGEIDENTIFIER]})(?:${a[c.PRERELEASE]})?${a[c.BUILD]}?)?)?`), + p("XRANGEPLAINLOOSE", `[v=\\s]*(${a[c.XRANGEIDENTIFIERLOOSE]})(?:\\.(${a[c.XRANGEIDENTIFIERLOOSE]})(?:\\.(${a[c.XRANGEIDENTIFIERLOOSE]})(?:${a[c.PRERELEASELOOSE]})?${a[c.BUILD]}?)?)?`), + p("XRANGE", `^${a[c.GTLT]}\\s*${a[c.XRANGEPLAIN]}$`), p("XRANGELOOSE", `^${a[c.GTLT]}\\s*${a[c.XRANGEPLAINLOOSE]}$`), + p("COERCE", `(^|[^\\d])(\\d{1,${r}})(?:\\.(\\d{1,${r}}))?(?:\\.(\\d{1,${r}}))?(?:$|[^\\d])`), + p("COERCERTL", a[c.COERCE], !0), p("LONETILDE", "(?:~>?)"), p("TILDETRIM", `(\\s*)${a[c.LONETILDE]}\\s+`, !0), + t.tildeTrimReplace = "$1~", p("TILDE", `^${a[c.LONETILDE]}${a[c.XRANGEPLAIN]}$`), + p("TILDELOOSE", `^${a[c.LONETILDE]}${a[c.XRANGEPLAINLOOSE]}$`), p("LONECARET", "(?:\\^)"), + p("CARETTRIM", `(\\s*)${a[c.LONECARET]}\\s+`, !0), t.caretTrimReplace = "$1^", p("CARET", `^${a[c.LONECARET]}${a[c.XRANGEPLAIN]}$`), + p("CARETLOOSE", `^${a[c.LONECARET]}${a[c.XRANGEPLAINLOOSE]}$`), p("COMPARATORLOOSE", `^${a[c.GTLT]}\\s*(${a[c.LOOSEPLAIN]})$|^$`), + p("COMPARATOR", `^${a[c.GTLT]}\\s*(${a[c.FULLPLAIN]})$|^$`), p("COMPARATORTRIM", `(\\s*)${a[c.GTLT]}\\s*(${a[c.LOOSEPLAIN]}|${a[c.XRANGEPLAIN]})`, !0), + t.comparatorTrimReplace = "$1$2$3", p("HYPHENRANGE", `^\\s*(${a[c.XRANGEPLAIN]})\\s+-\\s+(${a[c.XRANGEPLAIN]})\\s*$`), + p("HYPHENRANGELOOSE", `^\\s*(${a[c.XRANGEPLAINLOOSE]})\\s+-\\s+(${a[c.XRANGEPLAINLOOSE]})\\s*$`), + p("STAR", "(<|>)?=?\\s*\\*"), p("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), p("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$"); +}(D, D.exports); + +var v = D.exports; + +const y = Object.freeze({ + loose: !0 +}), C = Object.freeze({}); + +var A = e => e ? "object" != typeof e ? y : e : C; + +const F = /^[0-9]+$/, S = (e, t) => { + const r = F.test(e), n = F.test(t); + return r && n && (e = +e, t = +t), e === t ? 0 : r && !n ? -1 : n && !r ? 1 : e < t ? -1 : 1; +}; + +var O = { + compareIdentifiers: S, + rcompareIdentifiers: (e, t) => S(t, e) +}; + +const w = g, {MAX_LENGTH: _, MAX_SAFE_INTEGER: I} = m, {safeRe: b, t: R} = v, P = A, {compareIdentifiers: N} = O; + +let T = class { + constructor(e, t) { + if (t = P(t), e instanceof T) { + if (e.loose === !!t.loose && e.includePrerelease === !!t.includePrerelease) { + return e; + } + e = e.version; + } else if ("string" != typeof e) { + throw new TypeError(`Invalid version. Must be a string. Got type "${typeof e}".`); + } + if (e.length > _) { + throw new TypeError(`version is longer than ${_} characters`); + } + w("SemVer", e, t), this.options = t, this.loose = !!t.loose, this.includePrerelease = !!t.includePrerelease; + const r = e.trim().match(t.loose ? b[R.LOOSE] : b[R.FULL]); + if (!r) { + throw new TypeError(`Invalid Version: ${e}`); + } + if (this.raw = e, this.major = +r[1], this.minor = +r[2], this.patch = +r[3], this.major > I || this.major < 0) { + throw new TypeError("Invalid major version"); + } + if (this.minor > I || this.minor < 0) { + throw new TypeError("Invalid minor version"); + } + if (this.patch > I || this.patch < 0) { + throw new TypeError("Invalid patch version"); + } + r[4] ? this.prerelease = r[4].split(".").map((e => { + if (/^[0-9]+$/.test(e)) { + const t = +e; + if (t >= 0 && t < I) { + return t; + } + } + return e; + })) : this.prerelease = [], this.build = r[5] ? r[5].split(".") : [], this.format(); + } + format() { + return this.version = `${this.major}.${this.minor}.${this.patch}`, this.prerelease.length && (this.version += `-${this.prerelease.join(".")}`), + this.version; + } + toString() { + return this.version; + } + compare(e) { + if (w("SemVer.compare", this.version, this.options, e), !(e instanceof T)) { + if ("string" == typeof e && e === this.version) { + return 0; + } + e = new T(e, this.options); + } + return e.version === this.version ? 0 : this.compareMain(e) || this.comparePre(e); + } + compareMain(e) { + return e instanceof T || (e = new T(e, this.options)), N(this.major, e.major) || N(this.minor, e.minor) || N(this.patch, e.patch); + } + comparePre(e) { + if (e instanceof T || (e = new T(e, this.options)), this.prerelease.length && !e.prerelease.length) { + return -1; + } + if (!this.prerelease.length && e.prerelease.length) { + return 1; + } + if (!this.prerelease.length && !e.prerelease.length) { + return 0; + } + let t = 0; + do { + const r = this.prerelease[t], n = e.prerelease[t]; + if (w("prerelease compare", t, r, n), void 0 === r && void 0 === n) { + return 0; + } + if (void 0 === n) { + return 1; + } + if (void 0 === r) { + return -1; + } + if (r !== n) { + return N(r, n); + } + } while (++t); + } + compareBuild(e) { + e instanceof T || (e = new T(e, this.options)); + let t = 0; + do { + const r = this.build[t], n = e.build[t]; + if (w("prerelease compare", t, r, n), void 0 === r && void 0 === n) { + return 0; + } + if (void 0 === n) { + return 1; + } + if (void 0 === r) { + return -1; + } + if (r !== n) { + return N(r, n); + } + } while (++t); + } + inc(e, t, r) { + switch (e) { + case "premajor": + this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", t, r); + break; + + case "preminor": + this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", t, r); + break; + + case "prepatch": + this.prerelease.length = 0, this.inc("patch", t, r), this.inc("pre", t, r); + break; + + case "prerelease": + 0 === this.prerelease.length && this.inc("patch", t, r), this.inc("pre", t, r); + break; + + case "major": + 0 === this.minor && 0 === this.patch && 0 !== this.prerelease.length || this.major++, + this.minor = 0, this.patch = 0, this.prerelease = []; + break; + + case "minor": + 0 === this.patch && 0 !== this.prerelease.length || this.minor++, this.patch = 0, + this.prerelease = []; + break; + + case "patch": + 0 === this.prerelease.length && this.patch++, this.prerelease = []; + break; + + case "pre": + { + const e = Number(r) ? 1 : 0; + if (!t && !1 === r) { + throw new Error("invalid increment argument: identifier is empty"); + } + if (0 === this.prerelease.length) { + this.prerelease = [ e ]; + } else { + let n = this.prerelease.length; + for (;--n >= 0; ) { + "number" == typeof this.prerelease[n] && (this.prerelease[n]++, n = -2); + } + if (-1 === n) { + if (t === this.prerelease.join(".") && !1 === r) { + throw new Error("invalid increment argument: identifier already exists"); + } + this.prerelease.push(e); + } + } + if (t) { + let n = [ t, e ]; + !1 === r && (n = [ t ]), 0 === N(this.prerelease[0], t) ? isNaN(this.prerelease[1]) && (this.prerelease = n) : this.prerelease = n; + } + break; + } + + default: + throw new Error(`invalid increment argument: ${e}`); + } + return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), + this; + } +}; + +var L = T; + +const M = L; + +var B = (e, t, r = !1) => { + if (e instanceof M) { + return e; + } + try { + return new M(e, t); + } catch (e) { + if (!r) { + return null; + } + throw e; + } +}; + +const x = B; + +var k = (e, t) => { + const r = x(e, t); + return r ? r.version : null; +}; + +const $ = B; + +var j = (e, t) => { + const r = $(e.trim().replace(/^[=v]+/, ""), t); + return r ? r.version : null; +}; + +const H = L; + +var G = (e, t, r, n, i) => { + "string" == typeof r && (i = n, n = r, r = void 0); + try { + return new H(e instanceof H ? e.version : e, r).inc(t, n, i).version; + } catch (e) { + return null; + } +}; + +const U = B; + +var V = (e, t) => { + const r = U(e, null, !0), n = U(t, null, !0), i = r.compare(n); + if (0 === i) { + return null; + } + const o = i > 0, s = o ? r : n, u = o ? n : r, a = !!s.prerelease.length; + if (!!u.prerelease.length && !a) { + return u.patch || u.minor ? s.patch ? "patch" : s.minor ? "minor" : "major" : "major"; + } + const c = a ? "pre" : ""; + return r.major !== n.major ? c + "major" : r.minor !== n.minor ? c + "minor" : r.patch !== n.patch ? c + "patch" : "prerelease"; +}; + +const J = L; + +var W = (e, t) => new J(e, t).major; + +const z = L; + +var K = (e, t) => new z(e, t).minor; + +const X = L; + +var Y = (e, t) => new X(e, t).patch; + +const q = B; + +var Z = (e, t) => { + const r = q(e, t); + return r && r.prerelease.length ? r.prerelease : null; +}; + +const Q = L; + +var ee = (e, t, r) => new Q(e, r).compare(new Q(t, r)); + +const te = ee; + +var re = (e, t, r) => te(t, e, r); + +const ne = ee; + +var ie = (e, t) => ne(e, t, !0); + +const oe = L; + +var se = (e, t, r) => { + const n = new oe(e, r), i = new oe(t, r); + return n.compare(i) || n.compareBuild(i); +}; + +const ue = se; + +var ae = (e, t) => e.sort(((e, r) => ue(e, r, t))); + +const ce = se; + +var le = (e, t) => e.sort(((e, r) => ce(r, e, t))); + +const fe = ee; + +var de = (e, t, r) => fe(e, t, r) > 0; + +const pe = ee; + +var he = (e, t, r) => pe(e, t, r) < 0; + +const Ee = ee; + +var De = (e, t, r) => 0 === Ee(e, t, r); + +const me = ee; + +var ge = (e, t, r) => 0 !== me(e, t, r); + +const ve = ee; + +var ye = (e, t, r) => ve(e, t, r) >= 0; + +const Ce = ee; + +var Ae = (e, t, r) => Ce(e, t, r) <= 0; + +const Fe = De, Se = ge, Oe = de, we = ye, _e = he, Ie = Ae; + +var be = (e, t, r, n) => { + switch (t) { + case "===": + return "object" == typeof e && (e = e.version), "object" == typeof r && (r = r.version), + e === r; + + case "!==": + return "object" == typeof e && (e = e.version), "object" == typeof r && (r = r.version), + e !== r; + + case "": + case "=": + case "==": + return Fe(e, r, n); + + case "!=": + return Se(e, r, n); + + case ">": + return Oe(e, r, n); + + case ">=": + return we(e, r, n); + + case "<": + return _e(e, r, n); + + case "<=": + return Ie(e, r, n); + + default: + throw new TypeError(`Invalid operator: ${t}`); + } +}; + +const Re = L, Pe = B, {safeRe: Ne, t: Te} = v; + +var Le, Me, Be, xe, ke, $e, je, He, Ge, Ue, Ve = (e, t) => { + if (e instanceof Re) { + return e; + } + if ("number" == typeof e && (e = String(e)), "string" != typeof e) { + return null; + } + let r = null; + if ((t = t || {}).rtl) { + let t; + for (;(t = Ne[Te.COERCERTL].exec(e)) && (!r || r.index + r[0].length !== e.length); ) { + r && t.index + t[0].length === r.index + r[0].length || (r = t), Ne[Te.COERCERTL].lastIndex = t.index + t[1].length + t[2].length; + } + Ne[Te.COERCERTL].lastIndex = -1; + } else { + r = e.match(Ne[Te.COERCE]); + } + return null === r ? null : Pe(`${r[2]}.${r[3] || "0"}.${r[4] || "0"}`, t); +}; + +function Je() { + if (xe) { + return Be; + } + function e(t) { + var r = this; + if (r instanceof e || (r = new e), r.tail = null, r.head = null, r.length = 0, t && "function" == typeof t.forEach) { + t.forEach((function(e) { + r.push(e); + })); + } else if (arguments.length > 0) { + for (var n = 0, i = arguments.length; n < i; n++) { + r.push(arguments[n]); + } + } + return r; + } + function t(e, t, r) { + var n = t === e.head ? new i(r, null, t, e) : new i(r, t, t.next, e); + return null === n.next && (e.tail = n), null === n.prev && (e.head = n), e.length++, + n; + } + function r(e, t) { + e.tail = new i(t, e.tail, null, e), e.head || (e.head = e.tail), e.length++; + } + function n(e, t) { + e.head = new i(t, null, e.head, e), e.tail || (e.tail = e.head), e.length++; + } + function i(e, t, r, n) { + if (!(this instanceof i)) { + return new i(e, t, r, n); + } + this.list = n, this.value = e, t ? (t.next = this, this.prev = t) : this.prev = null, + r ? (r.prev = this, this.next = r) : this.next = null; + } + xe = 1, Be = e, e.Node = i, e.create = e, e.prototype.removeNode = function(e) { + if (e.list !== this) { + throw new Error("removing node which does not belong to this list"); + } + var t = e.next, r = e.prev; + return t && (t.prev = r), r && (r.next = t), e === this.head && (this.head = t), + e === this.tail && (this.tail = r), e.list.length--, e.next = null, e.prev = null, + e.list = null, t; + }, e.prototype.unshiftNode = function(e) { + if (e !== this.head) { + e.list && e.list.removeNode(e); + var t = this.head; + e.list = this, e.next = t, t && (t.prev = e), this.head = e, this.tail || (this.tail = e), + this.length++; + } + }, e.prototype.pushNode = function(e) { + if (e !== this.tail) { + e.list && e.list.removeNode(e); + var t = this.tail; + e.list = this, e.prev = t, t && (t.next = e), this.tail = e, this.head || (this.head = e), + this.length++; + } + }, e.prototype.push = function() { + for (var e = 0, t = arguments.length; e < t; e++) { + r(this, arguments[e]); + } + return this.length; + }, e.prototype.unshift = function() { + for (var e = 0, t = arguments.length; e < t; e++) { + n(this, arguments[e]); + } + return this.length; + }, e.prototype.pop = function() { + if (this.tail) { + var e = this.tail.value; + return this.tail = this.tail.prev, this.tail ? this.tail.next = null : this.head = null, + this.length--, e; + } + }, e.prototype.shift = function() { + if (this.head) { + var e = this.head.value; + return this.head = this.head.next, this.head ? this.head.prev = null : this.tail = null, + this.length--, e; + } + }, e.prototype.forEach = function(e, t) { + t = t || this; + for (var r = this.head, n = 0; null !== r; n++) { + e.call(t, r.value, n, this), r = r.next; + } + }, e.prototype.forEachReverse = function(e, t) { + t = t || this; + for (var r = this.tail, n = this.length - 1; null !== r; n--) { + e.call(t, r.value, n, this), r = r.prev; + } + }, e.prototype.get = function(e) { + for (var t = 0, r = this.head; null !== r && t < e; t++) { + r = r.next; + } + if (t === e && null !== r) { + return r.value; + } + }, e.prototype.getReverse = function(e) { + for (var t = 0, r = this.tail; null !== r && t < e; t++) { + r = r.prev; + } + if (t === e && null !== r) { + return r.value; + } + }, e.prototype.map = function(t, r) { + r = r || this; + for (var n = new e, i = this.head; null !== i; ) { + n.push(t.call(r, i.value, this)), i = i.next; + } + return n; + }, e.prototype.mapReverse = function(t, r) { + r = r || this; + for (var n = new e, i = this.tail; null !== i; ) { + n.push(t.call(r, i.value, this)), i = i.prev; + } + return n; + }, e.prototype.reduce = function(e, t) { + var r, n = this.head; + if (arguments.length > 1) { + r = t; + } else { + if (!this.head) { + throw new TypeError("Reduce of empty list with no initial value"); + } + n = this.head.next, r = this.head.value; + } + for (var i = 0; null !== n; i++) { + r = e(r, n.value, i), n = n.next; + } + return r; + }, e.prototype.reduceReverse = function(e, t) { + var r, n = this.tail; + if (arguments.length > 1) { + r = t; + } else { + if (!this.tail) { + throw new TypeError("Reduce of empty list with no initial value"); + } + n = this.tail.prev, r = this.tail.value; + } + for (var i = this.length - 1; null !== n; i--) { + r = e(r, n.value, i), n = n.prev; + } + return r; + }, e.prototype.toArray = function() { + for (var e = new Array(this.length), t = 0, r = this.head; null !== r; t++) { + e[t] = r.value, r = r.next; + } + return e; + }, e.prototype.toArrayReverse = function() { + for (var e = new Array(this.length), t = 0, r = this.tail; null !== r; t++) { + e[t] = r.value, r = r.prev; + } + return e; + }, e.prototype.slice = function(t, r) { + (r = r || this.length) < 0 && (r += this.length), (t = t || 0) < 0 && (t += this.length); + var n = new e; + if (r < t || r < 0) { + return n; + } + t < 0 && (t = 0), r > this.length && (r = this.length); + for (var i = 0, o = this.head; null !== o && i < t; i++) { + o = o.next; + } + for (;null !== o && i < r; i++, o = o.next) { + n.push(o.value); + } + return n; + }, e.prototype.sliceReverse = function(t, r) { + (r = r || this.length) < 0 && (r += this.length), (t = t || 0) < 0 && (t += this.length); + var n = new e; + if (r < t || r < 0) { + return n; + } + t < 0 && (t = 0), r > this.length && (r = this.length); + for (var i = this.length, o = this.tail; null !== o && i > r; i--) { + o = o.prev; + } + for (;null !== o && i > t; i--, o = o.prev) { + n.push(o.value); + } + return n; + }, e.prototype.splice = function(e, r, ...n) { + e > this.length && (e = this.length - 1), e < 0 && (e = this.length + e); + for (var i = 0, o = this.head; null !== o && i < e; i++) { + o = o.next; + } + var s = []; + for (i = 0; o && i < r; i++) { + s.push(o.value), o = this.removeNode(o); + } + null === o && (o = this.tail), o !== this.head && o !== this.tail && (o = o.prev); + for (i = 0; i < n.length; i++) { + o = t(this, o, n[i]); + } + return s; + }, e.prototype.reverse = function() { + for (var e = this.head, t = this.tail, r = e; null !== r; r = r.prev) { + var n = r.prev; + r.prev = r.next, r.next = n; + } + return this.head = t, this.tail = e, this; + }; + try { + (Me ? Le : (Me = 1, Le = function(e) { + e.prototype[Symbol.iterator] = function*() { + for (let e = this.head; e; e = e.next) { + yield e.value; + } + }; + }))(e); + } catch (e) {} + return Be; +} + +function We() { + if (He) { + return je; + } + He = 1; + class e { + constructor(t, r) { + if (r = n(r), t instanceof e) { + return t.loose === !!r.loose && t.includePrerelease === !!r.includePrerelease ? t : new e(t.raw, r); + } + if (t instanceof i) { + return this.raw = t.value, this.set = [ [ t ] ], this.format(), this; + } + if (this.options = r, this.loose = !!r.loose, this.includePrerelease = !!r.includePrerelease, + this.raw = t.trim().split(/\s+/).join(" "), this.set = this.raw.split("||").map((e => this.parseRange(e.trim()))).filter((e => e.length)), + !this.set.length) { + throw new TypeError(`Invalid SemVer Range: ${this.raw}`); + } + if (this.set.length > 1) { + const e = this.set[0]; + if (this.set = this.set.filter((e => !h(e[0]))), 0 === this.set.length) { + this.set = [ e ]; + } else if (this.set.length > 1) { + for (const e of this.set) { + if (1 === e.length && E(e[0])) { + this.set = [ e ]; + break; + } + } + } + } + this.format(); + } + format() { + return this.range = this.set.map((e => e.join(" ").trim())).join("||").trim(), this.range; + } + toString() { + return this.range; + } + parseRange(e) { + const t = ((this.options.includePrerelease && d) | (this.options.loose && p)) + ":" + e, n = r.get(t); + if (n) { + return n; + } + const s = this.options.loose, E = s ? u[a.HYPHENRANGELOOSE] : u[a.HYPHENRANGE]; + e = e.replace(E, P(this.options.includePrerelease)), o("hyphen replace", e), e = e.replace(u[a.COMPARATORTRIM], c), + o("comparator trim", e), e = e.replace(u[a.TILDETRIM], l), o("tilde trim", e), e = e.replace(u[a.CARETTRIM], f), + o("caret trim", e); + let D = e.split(" ").map((e => y(e, this.options))).join(" ").split(/\s+/).map((e => R(e, this.options))); + s && (D = D.filter((e => (o("loose invalid filter", e, this.options), !!e.match(u[a.COMPARATORLOOSE]))))), + o("range list", D); + const m = new Map, g = D.map((e => new i(e, this.options))); + for (const e of g) { + if (h(e)) { + return [ e ]; + } + m.set(e.value, e); + } + m.size > 1 && m.has("") && m.delete(""); + const v = [ ...m.values() ]; + return r.set(t, v), v; + } + intersects(t, r) { + if (!(t instanceof e)) { + throw new TypeError("a Range is required"); + } + return this.set.some((e => D(e, r) && t.set.some((t => D(t, r) && e.every((e => t.every((t => e.intersects(t, r))))))))); + } + test(e) { + if (!e) { + return !1; + } + if ("string" == typeof e) { + try { + e = new s(e, this.options); + } catch (e) { + return !1; + } + } + for (let t = 0; t < this.set.length; t++) { + if (N(this.set[t], e, this.options)) { + return !0; + } + } + return !1; + } + } + je = e; + const t = function() { + if ($e) { + return ke; + } + $e = 1; + const e = Je(), t = Symbol("max"), r = Symbol("length"), n = Symbol("lengthCalculator"), i = Symbol("allowStale"), o = Symbol("maxAge"), s = Symbol("dispose"), u = Symbol("noDisposeOnSet"), a = Symbol("lruList"), c = Symbol("cache"), l = Symbol("updateAgeOnGet"), f = () => 1, d = (e, t, r) => { + const n = e[c].get(t); + if (n) { + const t = n.value; + if (p(e, t)) { + if (E(e, n), !e[i]) { + return; + } + } else { + r && (e[l] && (n.value.now = Date.now()), e[a].unshiftNode(n)); + } + return t.value; + } + }, p = (e, t) => { + if (!t || !t.maxAge && !e[o]) { + return !1; + } + const r = Date.now() - t.now; + return t.maxAge ? r > t.maxAge : e[o] && r > e[o]; + }, h = e => { + if (e[r] > e[t]) { + for (let n = e[a].tail; e[r] > e[t] && null !== n; ) { + const t = n.prev; + E(e, n), n = t; + } + } + }, E = (e, t) => { + if (t) { + const n = t.value; + e[s] && e[s](n.key, n.value), e[r] -= n.length, e[c].delete(n.key), e[a].removeNode(t); + } + }; + class D { + constructor(e, t, r, n, i) { + this.key = e, this.value = t, this.length = r, this.now = n, this.maxAge = i || 0; + } + } + const m = (e, t, r, n) => { + let o = r.value; + p(e, o) && (E(e, r), e[i] || (o = void 0)), o && t.call(n, o.value, o.key, e); + }; + return ke = class { + constructor(e) { + if ("number" == typeof e && (e = { + max: e + }), e || (e = {}), e.max && ("number" != typeof e.max || e.max < 0)) { + throw new TypeError("max must be a non-negative number"); + } + this[t] = e.max || 1 / 0; + const r = e.length || f; + if (this[n] = "function" != typeof r ? f : r, this[i] = e.stale || !1, e.maxAge && "number" != typeof e.maxAge) { + throw new TypeError("maxAge must be a number"); + } + this[o] = e.maxAge || 0, this[s] = e.dispose, this[u] = e.noDisposeOnSet || !1, + this[l] = e.updateAgeOnGet || !1, this.reset(); + } + set max(e) { + if ("number" != typeof e || e < 0) { + throw new TypeError("max must be a non-negative number"); + } + this[t] = e || 1 / 0, h(this); + } + get max() { + return this[t]; + } + set allowStale(e) { + this[i] = !!e; + } + get allowStale() { + return this[i]; + } + set maxAge(e) { + if ("number" != typeof e) { + throw new TypeError("maxAge must be a non-negative number"); + } + this[o] = e, h(this); + } + get maxAge() { + return this[o]; + } + set lengthCalculator(e) { + "function" != typeof e && (e = f), e !== this[n] && (this[n] = e, this[r] = 0, this[a].forEach((e => { + e.length = this[n](e.value, e.key), this[r] += e.length; + }))), h(this); + } + get lengthCalculator() { + return this[n]; + } + get length() { + return this[r]; + } + get itemCount() { + return this[a].length; + } + rforEach(e, t) { + t = t || this; + for (let r = this[a].tail; null !== r; ) { + const n = r.prev; + m(this, e, r, t), r = n; + } + } + forEach(e, t) { + t = t || this; + for (let r = this[a].head; null !== r; ) { + const n = r.next; + m(this, e, r, t), r = n; + } + } + keys() { + return this[a].toArray().map((e => e.key)); + } + values() { + return this[a].toArray().map((e => e.value)); + } + reset() { + this[s] && this[a] && this[a].length && this[a].forEach((e => this[s](e.key, e.value))), + this[c] = new Map, this[a] = new e, this[r] = 0; + } + dump() { + return this[a].map((e => !p(this, e) && { + k: e.key, + v: e.value, + e: e.now + (e.maxAge || 0) + })).toArray().filter((e => e)); + } + dumpLru() { + return this[a]; + } + set(e, i, l) { + if ((l = l || this[o]) && "number" != typeof l) { + throw new TypeError("maxAge must be a number"); + } + const f = l ? Date.now() : 0, d = this[n](i, e); + if (this[c].has(e)) { + if (d > this[t]) { + return E(this, this[c].get(e)), !1; + } + const n = this[c].get(e).value; + return this[s] && (this[u] || this[s](e, n.value)), n.now = f, n.maxAge = l, n.value = i, + this[r] += d - n.length, n.length = d, this.get(e), h(this), !0; + } + const p = new D(e, i, d, f, l); + return p.length > this[t] ? (this[s] && this[s](e, i), !1) : (this[r] += p.length, + this[a].unshift(p), this[c].set(e, this[a].head), h(this), !0); + } + has(e) { + if (!this[c].has(e)) { + return !1; + } + const t = this[c].get(e).value; + return !p(this, t); + } + get(e) { + return d(this, e, !0); + } + peek(e) { + return d(this, e, !1); + } + pop() { + const e = this[a].tail; + return e ? (E(this, e), e.value) : null; + } + del(e) { + E(this, this[c].get(e)); + } + load(e) { + this.reset(); + const t = Date.now(); + for (let r = e.length - 1; r >= 0; r--) { + const n = e[r], i = n.e || 0; + if (0 === i) { + this.set(n.k, n.v); + } else { + const e = i - t; + e > 0 && this.set(n.k, n.v, e); + } + } + } + prune() { + this[c].forEach(((e, t) => d(this, t, !1))); + } + }, ke; + }(), r = new t({ + max: 1e3 + }), n = A, i = ze(), o = g, s = L, {safeRe: u, t: a, comparatorTrimReplace: c, tildeTrimReplace: l, caretTrimReplace: f} = v, {FLAG_INCLUDE_PRERELEASE: d, FLAG_LOOSE: p} = m, h = e => "<0.0.0-0" === e.value, E = e => "" === e.value, D = (e, t) => { + let r = !0; + const n = e.slice(); + let i = n.pop(); + for (;r && n.length; ) { + r = n.every((e => i.intersects(e, t))), i = n.pop(); + } + return r; + }, y = (e, t) => (o("comp", e, t), e = O(e, t), o("caret", e), e = F(e, t), o("tildes", e), + e = _(e, t), o("xrange", e), e = b(e, t), o("stars", e), e), C = e => !e || "x" === e.toLowerCase() || "*" === e, F = (e, t) => e.trim().split(/\s+/).map((e => S(e, t))).join(" "), S = (e, t) => { + const r = t.loose ? u[a.TILDELOOSE] : u[a.TILDE]; + return e.replace(r, ((t, r, n, i, s) => { + let u; + return o("tilde", e, t, r, n, i, s), C(r) ? u = "" : C(n) ? u = `>=${r}.0.0 <${+r + 1}.0.0-0` : C(i) ? u = `>=${r}.${n}.0 <${r}.${+n + 1}.0-0` : s ? (o("replaceTilde pr", s), + u = `>=${r}.${n}.${i}-${s} <${r}.${+n + 1}.0-0`) : u = `>=${r}.${n}.${i} <${r}.${+n + 1}.0-0`, + o("tilde return", u), u; + })); + }, O = (e, t) => e.trim().split(/\s+/).map((e => w(e, t))).join(" "), w = (e, t) => { + o("caret", e, t); + const r = t.loose ? u[a.CARETLOOSE] : u[a.CARET], n = t.includePrerelease ? "-0" : ""; + return e.replace(r, ((t, r, i, s, u) => { + let a; + return o("caret", e, t, r, i, s, u), C(r) ? a = "" : C(i) ? a = `>=${r}.0.0${n} <${+r + 1}.0.0-0` : C(s) ? a = "0" === r ? `>=${r}.${i}.0${n} <${r}.${+i + 1}.0-0` : `>=${r}.${i}.0${n} <${+r + 1}.0.0-0` : u ? (o("replaceCaret pr", u), + a = "0" === r ? "0" === i ? `>=${r}.${i}.${s}-${u} <${r}.${i}.${+s + 1}-0` : `>=${r}.${i}.${s}-${u} <${r}.${+i + 1}.0-0` : `>=${r}.${i}.${s}-${u} <${+r + 1}.0.0-0`) : (o("no pr"), + a = "0" === r ? "0" === i ? `>=${r}.${i}.${s}${n} <${r}.${i}.${+s + 1}-0` : `>=${r}.${i}.${s}${n} <${r}.${+i + 1}.0-0` : `>=${r}.${i}.${s} <${+r + 1}.0.0-0`), + o("caret return", a), a; + })); + }, _ = (e, t) => (o("replaceXRanges", e, t), e.split(/\s+/).map((e => I(e, t))).join(" ")), I = (e, t) => { + e = e.trim(); + const r = t.loose ? u[a.XRANGELOOSE] : u[a.XRANGE]; + return e.replace(r, ((r, n, i, s, u, a) => { + o("xRange", e, r, n, i, s, u, a); + const c = C(i), l = c || C(s), f = l || C(u), d = f; + return "=" === n && d && (n = ""), a = t.includePrerelease ? "-0" : "", c ? r = ">" === n || "<" === n ? "<0.0.0-0" : "*" : n && d ? (l && (s = 0), + u = 0, ">" === n ? (n = ">=", l ? (i = +i + 1, s = 0, u = 0) : (s = +s + 1, u = 0)) : "<=" === n && (n = "<", + l ? i = +i + 1 : s = +s + 1), "<" === n && (a = "-0"), r = `${n + i}.${s}.${u}${a}`) : l ? r = `>=${i}.0.0${a} <${+i + 1}.0.0-0` : f && (r = `>=${i}.${s}.0${a} <${i}.${+s + 1}.0-0`), + o("xRange return", r), r; + })); + }, b = (e, t) => (o("replaceStars", e, t), e.trim().replace(u[a.STAR], "")), R = (e, t) => (o("replaceGTE0", e, t), + e.trim().replace(u[t.includePrerelease ? a.GTE0PRE : a.GTE0], "")), P = e => (t, r, n, i, o, s, u, a, c, l, f, d, p) => `${r = C(n) ? "" : C(i) ? `>=${n}.0.0${e ? "-0" : ""}` : C(o) ? `>=${n}.${i}.0${e ? "-0" : ""}` : s ? `>=${r}` : `>=${r}${e ? "-0" : ""}`} ${a = C(c) ? "" : C(l) ? `<${+c + 1}.0.0-0` : C(f) ? `<${c}.${+l + 1}.0-0` : d ? `<=${c}.${l}.${f}-${d}` : e ? `<${c}.${l}.${+f + 1}-0` : `<=${a}`}`.trim(), N = (e, t, r) => { + for (let r = 0; r < e.length; r++) { + if (!e[r].test(t)) { + return !1; + } + } + if (t.prerelease.length && !r.includePrerelease) { + for (let r = 0; r < e.length; r++) { + if (o(e[r].semver), e[r].semver !== i.ANY && e[r].semver.prerelease.length > 0) { + const n = e[r].semver; + if (n.major === t.major && n.minor === t.minor && n.patch === t.patch) { + return !0; + } + } + } + return !1; + } + return !0; + }; + return je; +} + +function ze() { + if (Ue) { + return Ge; + } + Ue = 1; + const e = Symbol("SemVer ANY"); + class t { + static get ANY() { + return e; + } + constructor(n, i) { + if (i = r(i), n instanceof t) { + if (n.loose === !!i.loose) { + return n; + } + n = n.value; + } + n = n.trim().split(/\s+/).join(" "), s("comparator", n, i), this.options = i, this.loose = !!i.loose, + this.parse(n), this.semver === e ? this.value = "" : this.value = this.operator + this.semver.version, + s("comp", this); + } + parse(t) { + const r = this.options.loose ? n[i.COMPARATORLOOSE] : n[i.COMPARATOR], o = t.match(r); + if (!o) { + throw new TypeError(`Invalid comparator: ${t}`); + } + this.operator = void 0 !== o[1] ? o[1] : "", "=" === this.operator && (this.operator = ""), + o[2] ? this.semver = new u(o[2], this.options.loose) : this.semver = e; + } + toString() { + return this.value; + } + test(t) { + if (s("Comparator.test", t, this.options.loose), this.semver === e || t === e) { + return !0; + } + if ("string" == typeof t) { + try { + t = new u(t, this.options); + } catch (e) { + return !1; + } + } + return o(t, this.operator, this.semver, this.options); + } + intersects(e, n) { + if (!(e instanceof t)) { + throw new TypeError("a Comparator is required"); + } + return "" === this.operator ? "" === this.value || new a(e.value, n).test(this.value) : "" === e.operator ? "" === e.value || new a(this.value, n).test(e.semver) : (!(n = r(n)).includePrerelease || "<0.0.0-0" !== this.value && "<0.0.0-0" !== e.value) && (!(!n.includePrerelease && (this.value.startsWith("<0.0.0") || e.value.startsWith("<0.0.0"))) && (!(!this.operator.startsWith(">") || !e.operator.startsWith(">")) || (!(!this.operator.startsWith("<") || !e.operator.startsWith("<")) || (!(this.semver.version !== e.semver.version || !this.operator.includes("=") || !e.operator.includes("=")) || (!!(o(this.semver, "<", e.semver, n) && this.operator.startsWith(">") && e.operator.startsWith("<")) || !!(o(this.semver, ">", e.semver, n) && this.operator.startsWith("<") && e.operator.startsWith(">"))))))); + } + } + Ge = t; + const r = A, {safeRe: n, t: i} = v, o = be, s = g, u = L, a = We(); + return Ge; +} + +const Ke = We(); + +var Xe = (e, t, r) => { + try { + t = new Ke(t, r); + } catch (e) { + return !1; + } + return t.test(e); +}; + +const Ye = We(); + +var qe = (e, t) => new Ye(e, t).set.map((e => e.map((e => e.value)).join(" ").trim().split(" "))); + +const Ze = L, Qe = We(); + +var et = (e, t, r) => { + let n = null, i = null, o = null; + try { + o = new Qe(t, r); + } catch (e) { + return null; + } + return e.forEach((e => { + o.test(e) && (n && -1 !== i.compare(e) || (n = e, i = new Ze(n, r))); + })), n; +}; + +const tt = L, rt = We(); + +var nt = (e, t, r) => { + let n = null, i = null, o = null; + try { + o = new rt(t, r); + } catch (e) { + return null; + } + return e.forEach((e => { + o.test(e) && (n && 1 !== i.compare(e) || (n = e, i = new tt(n, r))); + })), n; +}; + +const it = L, ot = We(), st = de; + +var ut = (e, t) => { + e = new ot(e, t); + let r = new it("0.0.0"); + if (e.test(r)) { + return r; + } + if (r = new it("0.0.0-0"), e.test(r)) { + return r; + } + r = null; + for (let t = 0; t < e.set.length; ++t) { + const n = e.set[t]; + let i = null; + n.forEach((e => { + const t = new it(e.semver.version); + switch (e.operator) { + case ">": + 0 === t.prerelease.length ? t.patch++ : t.prerelease.push(0), t.raw = t.format(); + + case "": + case ">=": + i && !st(t, i) || (i = t); + break; + + case "<": + case "<=": + break; + + default: + throw new Error(`Unexpected operation: ${e.operator}`); + } + })), !i || r && !st(r, i) || (r = i); + } + return r && e.test(r) ? r : null; +}; + +const at = We(); + +var ct = (e, t) => { + try { + return new at(e, t).range || "*"; + } catch (e) { + return null; + } +}; + +const lt = L, ft = ze(), {ANY: dt} = ft, pt = We(), ht = Xe, Et = de, Dt = he, mt = Ae, gt = ye; + +var vt = (e, t, r, n) => { + let i, o, s, u, a; + switch (e = new lt(e, n), t = new pt(t, n), r) { + case ">": + i = Et, o = mt, s = Dt, u = ">", a = ">="; + break; + + case "<": + i = Dt, o = gt, s = Et, u = "<", a = "<="; + break; + + default: + throw new TypeError('Must provide a hilo val of "<" or ">"'); + } + if (ht(e, t, n)) { + return !1; + } + for (let r = 0; r < t.set.length; ++r) { + const c = t.set[r]; + let l = null, f = null; + if (c.forEach((e => { + e.semver === dt && (e = new ft(">=0.0.0")), l = l || e, f = f || e, i(e.semver, l.semver, n) ? l = e : s(e.semver, f.semver, n) && (f = e); + })), l.operator === u || l.operator === a) { + return !1; + } + if ((!f.operator || f.operator === u) && o(e, f.semver)) { + return !1; + } + if (f.operator === a && s(e, f.semver)) { + return !1; + } + } + return !0; +}; + +const yt = vt; + +var Ct = (e, t, r) => yt(e, t, ">", r); + +const At = vt; + +var Ft = (e, t, r) => At(e, t, "<", r); + +const St = We(); + +var Ot = (e, t, r) => (e = new St(e, r), t = new St(t, r), e.intersects(t, r)); + +const wt = Xe, _t = ee; + +const It = We(), bt = ze(), {ANY: Rt} = bt, Pt = Xe, Nt = ee, Tt = [ new bt(">=0.0.0-0") ], Lt = [ new bt(">=0.0.0") ], Mt = (e, t, r) => { + if (e === t) { + return !0; + } + if (1 === e.length && e[0].semver === Rt) { + if (1 === t.length && t[0].semver === Rt) { + return !0; + } + e = r.includePrerelease ? Tt : Lt; + } + if (1 === t.length && t[0].semver === Rt) { + if (r.includePrerelease) { + return !0; + } + t = Lt; + } + const n = new Set; + let i, o, s, u, a, c, l; + for (const t of e) { + ">" === t.operator || ">=" === t.operator ? i = Bt(i, t, r) : "<" === t.operator || "<=" === t.operator ? o = xt(o, t, r) : n.add(t.semver); + } + if (n.size > 1) { + return null; + } + if (i && o) { + if (s = Nt(i.semver, o.semver, r), s > 0) { + return null; + } + if (0 === s && (">=" !== i.operator || "<=" !== o.operator)) { + return null; + } + } + for (const e of n) { + if (i && !Pt(e, String(i), r)) { + return null; + } + if (o && !Pt(e, String(o), r)) { + return null; + } + for (const n of t) { + if (!Pt(e, String(n), r)) { + return !1; + } + } + return !0; + } + let f = !(!o || r.includePrerelease || !o.semver.prerelease.length) && o.semver, d = !(!i || r.includePrerelease || !i.semver.prerelease.length) && i.semver; + f && 1 === f.prerelease.length && "<" === o.operator && 0 === f.prerelease[0] && (f = !1); + for (const e of t) { + if (l = l || ">" === e.operator || ">=" === e.operator, c = c || "<" === e.operator || "<=" === e.operator, + i) { + if (d && e.semver.prerelease && e.semver.prerelease.length && e.semver.major === d.major && e.semver.minor === d.minor && e.semver.patch === d.patch && (d = !1), + ">" === e.operator || ">=" === e.operator) { + if (u = Bt(i, e, r), u === e && u !== i) { + return !1; + } + } else if (">=" === i.operator && !Pt(i.semver, String(e), r)) { + return !1; + } + } + if (o) { + if (f && e.semver.prerelease && e.semver.prerelease.length && e.semver.major === f.major && e.semver.minor === f.minor && e.semver.patch === f.patch && (f = !1), + "<" === e.operator || "<=" === e.operator) { + if (a = xt(o, e, r), a === e && a !== o) { + return !1; + } + } else if ("<=" === o.operator && !Pt(o.semver, String(e), r)) { + return !1; + } + } + if (!e.operator && (o || i) && 0 !== s) { + return !1; + } + } + return !(i && c && !o && 0 !== s) && (!(o && l && !i && 0 !== s) && (!d && !f)); +}, Bt = (e, t, r) => { + if (!e) { + return t; + } + const n = Nt(e.semver, t.semver, r); + return n > 0 ? e : n < 0 || ">" === t.operator && ">=" === e.operator ? t : e; +}, xt = (e, t, r) => { + if (!e) { + return t; + } + const n = Nt(e.semver, t.semver, r); + return n < 0 ? e : n > 0 || "<" === t.operator && "<=" === e.operator ? t : e; +}; + +var kt = (e, t, r = {}) => { + if (e === t) { + return !0; + } + e = new It(e, r), t = new It(t, r); + let n = !1; + e: for (const i of e.set) { + for (const e of t.set) { + const t = Mt(i, e, r); + if (n = n || null !== t, t) { + continue e; + } + } + if (n) { + return !1; + } + } + return !0; +}; + +const $t = v, jt = m, Ht = L, Gt = O, Ut = (e, t, r) => { + const n = []; + let i = null, o = null; + const s = e.sort(((e, t) => _t(e, t, r))); + for (const e of s) { + wt(e, t, r) ? (o = e, i || (i = e)) : (o && n.push([ i, o ]), o = null, i = null); + } + i && n.push([ i, null ]); + const u = []; + for (const [e, t] of n) { + e === t ? u.push(e) : t || e !== s[0] ? t ? e === s[0] ? u.push(`<=${t}`) : u.push(`${e} - ${t}`) : u.push(`>=${e}`) : u.push("*"); + } + const a = u.join(" || "), c = "string" == typeof t.raw ? t.raw : String(t); + return a.length < c.length ? a : t; +}; + +var Vt = { + parse: B, + valid: k, + clean: j, + inc: G, + diff: V, + major: W, + minor: K, + patch: Y, + prerelease: Z, + compare: ee, + rcompare: re, + compareLoose: ie, + compareBuild: se, + sort: ae, + rsort: le, + gt: de, + lt: he, + eq: De, + neq: ge, + gte: ye, + lte: Ae, + cmp: be, + coerce: Ve, + Comparator: ze(), + Range: We(), + satisfies: Xe, + toComparators: qe, + maxSatisfying: et, + minSatisfying: nt, + minVersion: ut, + validRange: ct, + outside: vt, + gtr: Ct, + ltr: Ft, + intersects: Ot, + simplifyRange: Ut, + subset: kt, + SemVer: Ht, + re: $t.re, + src: $t.src, + tokens: $t.t, + SEMVER_SPEC_VERSION: jt.SEMVER_SPEC_VERSION, + RELEASE_TYPES: jt.RELEASE_TYPES, + compareIdentifiers: Gt.compareIdentifiers, + rcompareIdentifiers: Gt.rcompareIdentifiers +}, Jt = {}; + +!function(e) { + var t = E && E.__importDefault || function(e) { + return e && e.__esModule ? e : { + default: e + }; + }; + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.maxPathLength = e.isMac = e.isLinux = e.isWindows = void 0; + const r = t(n), i = "Windows_NT", o = "Darwin"; + function s() { + return r.default.type() === i; + } + function u() { + return r.default.type() === o; + } + e.isWindows = s, e.isLinux = function() { + return "Linux" === r.default.type(); + }, e.isMac = u, e.maxPathLength = function() { + return u() ? 1016 : s() ? 259 : 4095; + }; +}(Jt); + +var Wt, zt = {}, Kt = {}; + +Wt = Kt, Object.defineProperty(Wt, "__esModule", { + value: !0 +}), Wt.logError = Wt.logInfo = Wt.logErrorAndExit = void 0, Wt.logErrorAndExit = function(e) { + e instanceof Error ? console.error(e.message) : console.error(e), process.exit(-1); +}, Wt.logInfo = function(e) { + console.log(e); +}, Wt.logError = function(e) { + console.error(e); +}; + +var Xt = {}, Yt = {}, qt = {}; + +!function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.LOG_LEVEL = e.ANALYZE = e.PARALLEL = e.INCREMENTAL = e.DAEMON = e.DOT = e.PROPERTIES = e.OHOS_ARK_COMPILE_SOURCE_MAP_DIR = e.HVIGOR_ENABLE_MEMORY_CACHE = e.OHOS_ARK_COMPILE_MAX_SIZE = e.HVIGOR_POOL_CACHE_TTL = e.HVIGOR_POOL_CACHE_CAPACITY = e.HVIGOR_POOL_MAX_CORE_SIZE = e.HVIGOR_POOL_MAX_SIZE = e.BUILD_CACHE_DIR = e.ENABLE_SIGN_TASK_KEY = e.HVIGOR_CACHE_DIR_KEY = e.WORK_SPACE = e.PROJECT_CACHES = e.HVIGOR_USER_HOME_DIR_NAME = e.DEFAULT_PACKAGE_JSON = e.DEFAULT_OH_PACKAGE_JSON_FILE_NAME = e.DEFAULT_HVIGOR_CONFIG_JSON_FILE_NAME = e.PNPM = e.HVIGOR = e.NPM_TOOL = e.PNPM_TOOL = e.HVIGOR_ENGINE_PACKAGE_NAME = void 0; + const t = Jt; + e.HVIGOR_ENGINE_PACKAGE_NAME = "@ohos/hvigor", e.PNPM_TOOL = (0, t.isWindows)() ? "pnpm.cmd" : "pnpm", + e.NPM_TOOL = (0, t.isWindows)() ? "npm.cmd" : "npm", e.HVIGOR = "hvigor", e.PNPM = "pnpm", + e.DEFAULT_HVIGOR_CONFIG_JSON_FILE_NAME = "hvigor-config.json5", e.DEFAULT_OH_PACKAGE_JSON_FILE_NAME = "oh-package.json5", + e.DEFAULT_PACKAGE_JSON = "package.json", e.HVIGOR_USER_HOME_DIR_NAME = ".hvigor", + e.PROJECT_CACHES = "project_caches", e.WORK_SPACE = "workspace", e.HVIGOR_CACHE_DIR_KEY = "hvigor.cacheDir", + e.ENABLE_SIGN_TASK_KEY = "enableSignTask", e.BUILD_CACHE_DIR = "build-cache-dir", + e.HVIGOR_POOL_MAX_SIZE = "hvigor.pool.maxSize", e.HVIGOR_POOL_MAX_CORE_SIZE = "hvigor.pool.maxCoreSize", + e.HVIGOR_POOL_CACHE_CAPACITY = "hvigor.pool.cache.capacity", e.HVIGOR_POOL_CACHE_TTL = "hvigor.pool.cache.ttl", + e.OHOS_ARK_COMPILE_MAX_SIZE = "ohos.arkCompile.maxSize", e.HVIGOR_ENABLE_MEMORY_CACHE = "hvigor.enableMemoryCache", + e.OHOS_ARK_COMPILE_SOURCE_MAP_DIR = "ohos.arkCompile.sourceMapDir", e.PROPERTIES = "properties", + e.DOT = ".", e.DAEMON = "daemon", e.INCREMENTAL = "incremental", e.PARALLEL = "typeCheck", + e.ANALYZE = "analyze", e.LOG_LEVEL = "logLevel"; +}(qt); + +var Zt = {}, Qt = {}, er = {}, tr = { + fromCallback: function(e) { + return Object.defineProperty((function(...t) { + if ("function" != typeof t[t.length - 1]) { + return new Promise(((r, n) => { + t.push(((e, t) => null != e ? n(e) : r(t))), e.apply(this, t); + })); + } + e.apply(this, t); + }), "name", { + value: e.name + }); + }, + fromPromise: function(e) { + return Object.defineProperty((function(...t) { + const r = t[t.length - 1]; + if ("function" != typeof r) { + return e.apply(this, t); + } + t.pop(), e.apply(this, t).then((e => r(null, e)), r); + }), "name", { + value: e.name + }); + } +}, rr = o, nr = process.cwd, ir = null, or = process.env.GRACEFUL_FS_PLATFORM || process.platform; + +process.cwd = function() { + return ir || (ir = nr.call(process)), ir; +}; + +try { + process.cwd(); +} catch (e) {} + +if ("function" == typeof process.chdir) { + var sr = process.chdir; + process.chdir = function(e) { + ir = null, sr.call(process, e); + }, Object.setPrototypeOf && Object.setPrototypeOf(process.chdir, sr); +} + +var ur = function(e) { + rr.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./) && function(e) { + e.lchmod = function(t, r, n) { + e.open(t, rr.O_WRONLY | rr.O_SYMLINK, r, (function(t, i) { + t ? n && n(t) : e.fchmod(i, r, (function(t) { + e.close(i, (function(e) { + n && n(t || e); + })); + })); + })); + }, e.lchmodSync = function(t, r) { + var n, i = e.openSync(t, rr.O_WRONLY | rr.O_SYMLINK, r), o = !0; + try { + n = e.fchmodSync(i, r), o = !1; + } finally { + if (o) { + try { + e.closeSync(i); + } catch (e) {} + } else { + e.closeSync(i); + } + } + return n; + }; + }(e); + e.lutimes || function(e) { + rr.hasOwnProperty("O_SYMLINK") && e.futimes ? (e.lutimes = function(t, r, n, i) { + e.open(t, rr.O_SYMLINK, (function(t, o) { + t ? i && i(t) : e.futimes(o, r, n, (function(t) { + e.close(o, (function(e) { + i && i(t || e); + })); + })); + })); + }, e.lutimesSync = function(t, r, n) { + var i, o = e.openSync(t, rr.O_SYMLINK), s = !0; + try { + i = e.futimesSync(o, r, n), s = !1; + } finally { + if (s) { + try { + e.closeSync(o); + } catch (e) {} + } else { + e.closeSync(o); + } + } + return i; + }) : e.futimes && (e.lutimes = function(e, t, r, n) { + n && process.nextTick(n); + }, e.lutimesSync = function() {}); + }(e); + e.chown = n(e.chown), e.fchown = n(e.fchown), e.lchown = n(e.lchown), e.chmod = t(e.chmod), + e.fchmod = t(e.fchmod), e.lchmod = t(e.lchmod), e.chownSync = i(e.chownSync), e.fchownSync = i(e.fchownSync), + e.lchownSync = i(e.lchownSync), e.chmodSync = r(e.chmodSync), e.fchmodSync = r(e.fchmodSync), + e.lchmodSync = r(e.lchmodSync), e.stat = o(e.stat), e.fstat = o(e.fstat), e.lstat = o(e.lstat), + e.statSync = s(e.statSync), e.fstatSync = s(e.fstatSync), e.lstatSync = s(e.lstatSync), + e.chmod && !e.lchmod && (e.lchmod = function(e, t, r) { + r && process.nextTick(r); + }, e.lchmodSync = function() {}); + e.chown && !e.lchown && (e.lchown = function(e, t, r, n) { + n && process.nextTick(n); + }, e.lchownSync = function() {}); + "win32" === or && (e.rename = "function" != typeof e.rename ? e.rename : function(t) { + function r(r, n, i) { + var o = Date.now(), s = 0; + t(r, n, (function u(a) { + if (a && ("EACCES" === a.code || "EPERM" === a.code || "EBUSY" === a.code) && Date.now() - o < 6e4) { + return setTimeout((function() { + e.stat(n, (function(e, o) { + e && "ENOENT" === e.code ? t(r, n, u) : i(a); + })); + }), s), void (s < 100 && (s += 10)); + } + i && i(a); + })); + } + return Object.setPrototypeOf && Object.setPrototypeOf(r, t), r; + }(e.rename)); + function t(t) { + return t ? function(r, n, i) { + return t.call(e, r, n, (function(e) { + u(e) && (e = null), i && i.apply(this, arguments); + })); + } : t; + } + function r(t) { + return t ? function(r, n) { + try { + return t.call(e, r, n); + } catch (e) { + if (!u(e)) { + throw e; + } + } + } : t; + } + function n(t) { + return t ? function(r, n, i, o) { + return t.call(e, r, n, i, (function(e) { + u(e) && (e = null), o && o.apply(this, arguments); + })); + } : t; + } + function i(t) { + return t ? function(r, n, i) { + try { + return t.call(e, r, n, i); + } catch (e) { + if (!u(e)) { + throw e; + } + } + } : t; + } + function o(t) { + return t ? function(r, n, i) { + function o(e, t) { + t && (t.uid < 0 && (t.uid += 4294967296), t.gid < 0 && (t.gid += 4294967296)), i && i.apply(this, arguments); + } + return "function" == typeof n && (i = n, n = null), n ? t.call(e, r, n, o) : t.call(e, r, o); + } : t; + } + function s(t) { + return t ? function(r, n) { + var i = n ? t.call(e, r, n) : t.call(e, r); + return i && (i.uid < 0 && (i.uid += 4294967296), i.gid < 0 && (i.gid += 4294967296)), + i; + } : t; + } + function u(e) { + return !e || ("ENOSYS" === e.code || !(process.getuid && 0 === process.getuid() || "EINVAL" !== e.code && "EPERM" !== e.code)); + } + e.read = "function" != typeof e.read ? e.read : function(t) { + function r(r, n, i, o, s, u) { + var a; + if (u && "function" == typeof u) { + var c = 0; + a = function(l, f, d) { + if (l && "EAGAIN" === l.code && c < 10) { + return c++, t.call(e, r, n, i, o, s, a); + } + u.apply(this, arguments); + }; + } + return t.call(e, r, n, i, o, s, a); + } + return Object.setPrototypeOf && Object.setPrototypeOf(r, t), r; + }(e.read), e.readSync = "function" != typeof e.readSync ? e.readSync : (a = e.readSync, + function(t, r, n, i, o) { + for (var s = 0; ;) { + try { + return a.call(e, t, r, n, i, o); + } catch (e) { + if ("EAGAIN" === e.code && s < 10) { + s++; + continue; + } + throw e; + } + } + }); + var a; +}; + +var ar = s.Stream, cr = function(e) { + return { + ReadStream: function t(r, n) { + if (!(this instanceof t)) { + return new t(r, n); + } + ar.call(this); + var i = this; + this.path = r, this.fd = null, this.readable = !0, this.paused = !1, this.flags = "r", + this.mode = 438, this.bufferSize = 65536, n = n || {}; + for (var o = Object.keys(n), s = 0, u = o.length; s < u; s++) { + var a = o[s]; + this[a] = n[a]; + } + this.encoding && this.setEncoding(this.encoding); + if (void 0 !== this.start) { + if ("number" != typeof this.start) { + throw TypeError("start must be a Number"); + } + if (void 0 === this.end) { + this.end = 1 / 0; + } else if ("number" != typeof this.end) { + throw TypeError("end must be a Number"); + } + if (this.start > this.end) { + throw new Error("start must be <= end"); + } + this.pos = this.start; + } + if (null !== this.fd) { + return void process.nextTick((function() { + i._read(); + })); + } + e.open(this.path, this.flags, this.mode, (function(e, t) { + if (e) { + return i.emit("error", e), void (i.readable = !1); + } + i.fd = t, i.emit("open", t), i._read(); + })); + }, + WriteStream: function t(r, n) { + if (!(this instanceof t)) { + return new t(r, n); + } + ar.call(this), this.path = r, this.fd = null, this.writable = !0, this.flags = "w", + this.encoding = "binary", this.mode = 438, this.bytesWritten = 0, n = n || {}; + for (var i = Object.keys(n), o = 0, s = i.length; o < s; o++) { + var u = i[o]; + this[u] = n[u]; + } + if (void 0 !== this.start) { + if ("number" != typeof this.start) { + throw TypeError("start must be a Number"); + } + if (this.start < 0) { + throw new Error("start must be >= zero"); + } + this.pos = this.start; + } + this.busy = !1, this._queue = [], null === this.fd && (this._open = e.open, this._queue.push([ this._open, this.path, this.flags, this.mode, void 0 ]), + this.flush()); + } + }; +}; + +var lr = function(e) { + if (null === e || "object" != typeof e) { + return e; + } + if (e instanceof Object) { + var t = { + __proto__: fr(e) + }; + } else { + t = Object.create(null); + } + return Object.getOwnPropertyNames(e).forEach((function(r) { + Object.defineProperty(t, r, Object.getOwnPropertyDescriptor(e, r)); + })), t; +}, fr = Object.getPrototypeOf || function(e) { + return e.__proto__; +}; + +var dr, pr, hr = e, Er = ur, Dr = cr, mr = lr, gr = u; + +function vr(e, t) { + Object.defineProperty(e, dr, { + get: function() { + return t; + } + }); +} + +"function" == typeof Symbol && "function" == typeof Symbol.for ? (dr = Symbol.for("graceful-fs.queue"), +pr = Symbol.for("graceful-fs.previous")) : (dr = "___graceful-fs.queue", pr = "___graceful-fs.previous"); + +var yr = function() {}; + +if (gr.debuglog ? yr = gr.debuglog("gfs4") : /\bgfs4\b/i.test(process.env.NODE_DEBUG || "") && (yr = function() { + var e = gr.format.apply(gr, arguments); + e = "GFS4: " + e.split(/\n/).join("\nGFS4: "), console.error(e); +}), !hr[dr]) { + var Cr = E[dr] || []; + vr(hr, Cr), hr.close = function(e) { + function t(t, r) { + return e.call(hr, t, (function(e) { + e || wr(), "function" == typeof r && r.apply(this, arguments); + })); + } + return Object.defineProperty(t, pr, { + value: e + }), t; + }(hr.close), hr.closeSync = function(e) { + function t(t) { + e.apply(hr, arguments), wr(); + } + return Object.defineProperty(t, pr, { + value: e + }), t; + }(hr.closeSync), /\bgfs4\b/i.test(process.env.NODE_DEBUG || "") && process.on("exit", (function() { + yr(hr[dr]), a.equal(hr[dr].length, 0); + })); +} + +E[dr] || vr(E, hr[dr]); + +var Ar, Fr = Sr(mr(hr)); + +function Sr(e) { + Er(e), e.gracefulify = Sr, e.createReadStream = function(t, r) { + return new e.ReadStream(t, r); + }, e.createWriteStream = function(t, r) { + return new e.WriteStream(t, r); + }; + var t = e.readFile; + e.readFile = function(e, r, n) { + "function" == typeof r && (n = r, r = null); + return function e(r, n, i, o) { + return t(r, n, (function(t) { + !t || "EMFILE" !== t.code && "ENFILE" !== t.code ? "function" == typeof i && i.apply(this, arguments) : Or([ e, [ r, n, i ], t, o || Date.now(), Date.now() ]); + })); + }(e, r, n); + }; + var r = e.writeFile; + e.writeFile = function(e, t, n, i) { + "function" == typeof n && (i = n, n = null); + return function e(t, n, i, o, s) { + return r(t, n, i, (function(r) { + !r || "EMFILE" !== r.code && "ENFILE" !== r.code ? "function" == typeof o && o.apply(this, arguments) : Or([ e, [ t, n, i, o ], r, s || Date.now(), Date.now() ]); + })); + }(e, t, n, i); + }; + var n = e.appendFile; + n && (e.appendFile = function(e, t, r, i) { + "function" == typeof r && (i = r, r = null); + return function e(t, r, i, o, s) { + return n(t, r, i, (function(n) { + !n || "EMFILE" !== n.code && "ENFILE" !== n.code ? "function" == typeof o && o.apply(this, arguments) : Or([ e, [ t, r, i, o ], n, s || Date.now(), Date.now() ]); + })); + }(e, t, r, i); + }); + var i = e.copyFile; + i && (e.copyFile = function(e, t, r, n) { + "function" == typeof r && (n = r, r = 0); + return function e(t, r, n, o, s) { + return i(t, r, n, (function(i) { + !i || "EMFILE" !== i.code && "ENFILE" !== i.code ? "function" == typeof o && o.apply(this, arguments) : Or([ e, [ t, r, n, o ], i, s || Date.now(), Date.now() ]); + })); + }(e, t, r, n); + }); + var o = e.readdir; + e.readdir = function(e, t, r) { + "function" == typeof t && (r = t, t = null); + var n = s.test(process.version) ? function(e, t, r, n) { + return o(e, i(e, t, r, n)); + } : function(e, t, r, n) { + return o(e, t, i(e, t, r, n)); + }; + return n(e, t, r); + function i(e, t, r, i) { + return function(o, s) { + !o || "EMFILE" !== o.code && "ENFILE" !== o.code ? (s && s.sort && s.sort(), "function" == typeof r && r.call(this, o, s)) : Or([ n, [ e, t, r ], o, i || Date.now(), Date.now() ]); + }; + } + }; + var s = /^v[0-5]\./; + if ("v0.8" === process.version.substr(0, 4)) { + var u = Dr(e); + d = u.ReadStream, p = u.WriteStream; + } + var a = e.ReadStream; + a && (d.prototype = Object.create(a.prototype), d.prototype.open = function() { + var e = this; + E(e.path, e.flags, e.mode, (function(t, r) { + t ? (e.autoClose && e.destroy(), e.emit("error", t)) : (e.fd = r, e.emit("open", r), + e.read()); + })); + }); + var c = e.WriteStream; + c && (p.prototype = Object.create(c.prototype), p.prototype.open = function() { + var e = this; + E(e.path, e.flags, e.mode, (function(t, r) { + t ? (e.destroy(), e.emit("error", t)) : (e.fd = r, e.emit("open", r)); + })); + }), Object.defineProperty(e, "ReadStream", { + get: function() { + return d; + }, + set: function(e) { + d = e; + }, + enumerable: !0, + configurable: !0 + }), Object.defineProperty(e, "WriteStream", { + get: function() { + return p; + }, + set: function(e) { + p = e; + }, + enumerable: !0, + configurable: !0 + }); + var l = d; + Object.defineProperty(e, "FileReadStream", { + get: function() { + return l; + }, + set: function(e) { + l = e; + }, + enumerable: !0, + configurable: !0 + }); + var f = p; + function d(e, t) { + return this instanceof d ? (a.apply(this, arguments), this) : d.apply(Object.create(d.prototype), arguments); + } + function p(e, t) { + return this instanceof p ? (c.apply(this, arguments), this) : p.apply(Object.create(p.prototype), arguments); + } + Object.defineProperty(e, "FileWriteStream", { + get: function() { + return f; + }, + set: function(e) { + f = e; + }, + enumerable: !0, + configurable: !0 + }); + var h = e.open; + function E(e, t, r, n) { + return "function" == typeof r && (n = r, r = null), function e(t, r, n, i, o) { + return h(t, r, n, (function(s, u) { + !s || "EMFILE" !== s.code && "ENFILE" !== s.code ? "function" == typeof i && i.apply(this, arguments) : Or([ e, [ t, r, n, i ], s, o || Date.now(), Date.now() ]); + })); + }(e, t, r, n); + } + return e.open = E, e; +} + +function Or(e) { + yr("ENQUEUE", e[0].name, e[1]), hr[dr].push(e), _r(); +} + +function wr() { + for (var e = Date.now(), t = 0; t < hr[dr].length; ++t) { + hr[dr][t].length > 2 && (hr[dr][t][3] = e, hr[dr][t][4] = e); + } + _r(); +} + +function _r() { + if (clearTimeout(Ar), Ar = void 0, 0 !== hr[dr].length) { + var e = hr[dr].shift(), t = e[0], r = e[1], n = e[2], i = e[3], o = e[4]; + if (void 0 === i) { + yr("RETRY", t.name, r), t.apply(null, r); + } else if (Date.now() - i >= 6e4) { + yr("TIMEOUT", t.name, r); + var s = r.pop(); + "function" == typeof s && s.call(null, n); + } else { + var u = Date.now() - o, a = Math.max(o - i, 1); + u >= Math.min(1.2 * a, 100) ? (yr("RETRY", t.name, r), t.apply(null, r.concat([ i ]))) : hr[dr].push(e); + } + void 0 === Ar && (Ar = setTimeout(_r, 0)); + } +} + +process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !hr.__patched && (Fr = Sr(hr), hr.__patched = !0), +function(e) { + const t = tr.fromCallback, r = Fr, n = [ "access", "appendFile", "chmod", "chown", "close", "copyFile", "fchmod", "fchown", "fdatasync", "fstat", "fsync", "ftruncate", "futimes", "lchmod", "lchown", "link", "lstat", "mkdir", "mkdtemp", "open", "opendir", "readdir", "readFile", "readlink", "realpath", "rename", "rm", "rmdir", "stat", "symlink", "truncate", "unlink", "utimes", "writeFile" ].filter((e => "function" == typeof r[e])); + Object.assign(e, r), n.forEach((n => { + e[n] = t(r[n]); + })), e.exists = function(e, t) { + return "function" == typeof t ? r.exists(e, t) : new Promise((t => r.exists(e, t))); + }, e.read = function(e, t, n, i, o, s) { + return "function" == typeof s ? r.read(e, t, n, i, o, s) : new Promise(((s, u) => { + r.read(e, t, n, i, o, ((e, t, r) => { + if (e) { + return u(e); + } + s({ + bytesRead: t, + buffer: r + }); + })); + })); + }, e.write = function(e, t, ...n) { + return "function" == typeof n[n.length - 1] ? r.write(e, t, ...n) : new Promise(((i, o) => { + r.write(e, t, ...n, ((e, t, r) => { + if (e) { + return o(e); + } + i({ + bytesWritten: t, + buffer: r + }); + })); + })); + }, e.readv = function(e, t, ...n) { + return "function" == typeof n[n.length - 1] ? r.readv(e, t, ...n) : new Promise(((i, o) => { + r.readv(e, t, ...n, ((e, t, r) => { + if (e) { + return o(e); + } + i({ + bytesRead: t, + buffers: r + }); + })); + })); + }, e.writev = function(e, t, ...n) { + return "function" == typeof n[n.length - 1] ? r.writev(e, t, ...n) : new Promise(((i, o) => { + r.writev(e, t, ...n, ((e, t, r) => { + if (e) { + return o(e); + } + i({ + bytesWritten: t, + buffers: r + }); + })); + })); + }, "function" == typeof r.realpath.native ? e.realpath.native = t(r.realpath.native) : process.emitWarning("fs.realpath.native is not a function. Is fs being monkey-patched?", "Warning", "fs-extra-WARN0003"); +}(er); + +var Ir = {}, br = {}; + +const Rr = t; + +br.checkPath = function(e) { + if ("win32" === process.platform) { + if (/[<>:"|?*]/.test(e.replace(Rr.parse(e).root, ""))) { + const t = new Error(`Path contains invalid characters: ${e}`); + throw t.code = "EINVAL", t; + } + } +}; + +const Pr = er, {checkPath: Nr} = br, Tr = e => "number" == typeof e ? e : { + mode: 511, + ...e +}.mode; + +Ir.makeDir = async (e, t) => (Nr(e), Pr.mkdir(e, { + mode: Tr(t), + recursive: !0 +})), Ir.makeDirSync = (e, t) => (Nr(e), Pr.mkdirSync(e, { + mode: Tr(t), + recursive: !0 +})); + +const Lr = tr.fromPromise, {makeDir: Mr, makeDirSync: Br} = Ir, xr = Lr(Mr); + +var kr = { + mkdirs: xr, + mkdirsSync: Br, + mkdirp: xr, + mkdirpSync: Br, + ensureDir: xr, + ensureDirSync: Br +}; + +const $r = tr.fromPromise, jr = er; + +var Hr = { + pathExists: $r((function(e) { + return jr.access(e).then((() => !0)).catch((() => !1)); + })), + pathExistsSync: jr.existsSync +}; + +const Gr = Fr; + +var Ur = function(e, t, r, n) { + Gr.open(e, "r+", ((e, i) => { + if (e) { + return n(e); + } + Gr.futimes(i, t, r, (e => { + Gr.close(i, (t => { + n && n(e || t); + })); + })); + })); +}, Vr = function(e, t, r) { + const n = Gr.openSync(e, "r+"); + return Gr.futimesSync(n, t, r), Gr.closeSync(n); +}; + +const Jr = er, Wr = t, zr = u; + +function Kr(e, t, r) { + const n = r.dereference ? e => Jr.stat(e, { + bigint: !0 + }) : e => Jr.lstat(e, { + bigint: !0 + }); + return Promise.all([ n(e), n(t).catch((e => { + if ("ENOENT" === e.code) { + return null; + } + throw e; + })) ]).then((([e, t]) => ({ + srcStat: e, + destStat: t + }))); +} + +function Xr(e, t) { + return t.ino && t.dev && t.ino === e.ino && t.dev === e.dev; +} + +function Yr(e, t) { + const r = Wr.resolve(e).split(Wr.sep).filter((e => e)), n = Wr.resolve(t).split(Wr.sep).filter((e => e)); + return r.reduce(((e, t, r) => e && n[r] === t), !0); +} + +function qr(e, t, r) { + return `Cannot ${r} '${e}' to a subdirectory of itself, '${t}'.`; +} + +var Zr = { + checkPaths: function(e, t, r, n, i) { + zr.callbackify(Kr)(e, t, n, ((n, o) => { + if (n) { + return i(n); + } + const {srcStat: s, destStat: u} = o; + if (u) { + if (Xr(s, u)) { + const n = Wr.basename(e), o = Wr.basename(t); + return "move" === r && n !== o && n.toLowerCase() === o.toLowerCase() ? i(null, { + srcStat: s, + destStat: u, + isChangingCase: !0 + }) : i(new Error("Source and destination must not be the same.")); + } + if (s.isDirectory() && !u.isDirectory()) { + return i(new Error(`Cannot overwrite non-directory '${t}' with directory '${e}'.`)); + } + if (!s.isDirectory() && u.isDirectory()) { + return i(new Error(`Cannot overwrite directory '${t}' with non-directory '${e}'.`)); + } + } + return s.isDirectory() && Yr(e, t) ? i(new Error(qr(e, t, r))) : i(null, { + srcStat: s, + destStat: u + }); + })); + }, + checkPathsSync: function(e, t, r, n) { + const {srcStat: i, destStat: o} = function(e, t, r) { + let n; + const i = r.dereference ? e => Jr.statSync(e, { + bigint: !0 + }) : e => Jr.lstatSync(e, { + bigint: !0 + }), o = i(e); + try { + n = i(t); + } catch (e) { + if ("ENOENT" === e.code) { + return { + srcStat: o, + destStat: null + }; + } + throw e; + } + return { + srcStat: o, + destStat: n + }; + }(e, t, n); + if (o) { + if (Xr(i, o)) { + const n = Wr.basename(e), s = Wr.basename(t); + if ("move" === r && n !== s && n.toLowerCase() === s.toLowerCase()) { + return { + srcStat: i, + destStat: o, + isChangingCase: !0 + }; + } + throw new Error("Source and destination must not be the same."); + } + if (i.isDirectory() && !o.isDirectory()) { + throw new Error(`Cannot overwrite non-directory '${t}' with directory '${e}'.`); + } + if (!i.isDirectory() && o.isDirectory()) { + throw new Error(`Cannot overwrite directory '${t}' with non-directory '${e}'.`); + } + } + if (i.isDirectory() && Yr(e, t)) { + throw new Error(qr(e, t, r)); + } + return { + srcStat: i, + destStat: o + }; + }, + checkParentPaths: function e(t, r, n, i, o) { + const s = Wr.resolve(Wr.dirname(t)), u = Wr.resolve(Wr.dirname(n)); + if (u === s || u === Wr.parse(u).root) { + return o(); + } + Jr.stat(u, { + bigint: !0 + }, ((s, a) => s ? "ENOENT" === s.code ? o() : o(s) : Xr(r, a) ? o(new Error(qr(t, n, i))) : e(t, r, u, i, o))); + }, + checkParentPathsSync: function e(t, r, n, i) { + const o = Wr.resolve(Wr.dirname(t)), s = Wr.resolve(Wr.dirname(n)); + if (s === o || s === Wr.parse(s).root) { + return; + } + let u; + try { + u = Jr.statSync(s, { + bigint: !0 + }); + } catch (e) { + if ("ENOENT" === e.code) { + return; + } + throw e; + } + if (Xr(r, u)) { + throw new Error(qr(t, n, i)); + } + return e(t, r, s, i); + }, + isSrcSubdir: Yr, + areIdentical: Xr +}; + +const Qr = Fr, en = t, tn = kr.mkdirs, rn = Hr.pathExists, nn = Ur, on = Zr; + +function sn(e, t, r, n) { + if (!r.filter) { + return n(null, !0); + } + Promise.resolve(r.filter(e, t)).then((e => n(null, e)), (e => n(e))); +} + +function un(e, t, r, n, i) { + (n.dereference ? Qr.stat : Qr.lstat)(t, ((o, s) => o ? i(o) : s.isDirectory() ? function(e, t, r, n, i, o) { + return t ? fn(r, n, i, o) : function(e, t, r, n, i) { + Qr.mkdir(r, (o => { + if (o) { + return i(o); + } + fn(t, r, n, (t => t ? i(t) : ln(r, e, i))); + })); + }(e.mode, r, n, i, o); + }(s, e, t, r, n, i) : s.isFile() || s.isCharacterDevice() || s.isBlockDevice() ? function(e, t, r, n, i, o) { + return t ? function(e, t, r, n, i) { + if (!n.overwrite) { + return n.errorOnExist ? i(new Error(`'${r}' already exists`)) : i(); + } + Qr.unlink(r, (o => o ? i(o) : an(e, t, r, n, i))); + }(e, r, n, i, o) : an(e, r, n, i, o); + }(s, e, t, r, n, i) : s.isSymbolicLink() ? function(e, t, r, n, i) { + Qr.readlink(t, ((t, o) => t ? i(t) : (n.dereference && (o = en.resolve(process.cwd(), o)), + e ? void Qr.readlink(r, ((e, t) => e ? "EINVAL" === e.code || "UNKNOWN" === e.code ? Qr.symlink(o, r, i) : i(e) : (n.dereference && (t = en.resolve(process.cwd(), t)), + on.isSrcSubdir(o, t) ? i(new Error(`Cannot copy '${o}' to a subdirectory of itself, '${t}'.`)) : on.isSrcSubdir(t, o) ? i(new Error(`Cannot overwrite '${t}' with '${o}'.`)) : function(e, t, r) { + Qr.unlink(t, (n => n ? r(n) : Qr.symlink(e, t, r))); + }(o, r, i)))) : Qr.symlink(o, r, i)))); + }(e, t, r, n, i) : s.isSocket() ? i(new Error(`Cannot copy a socket file: ${t}`)) : s.isFIFO() ? i(new Error(`Cannot copy a FIFO pipe: ${t}`)) : i(new Error(`Unknown file: ${t}`)))); +} + +function an(e, t, r, n, i) { + Qr.copyFile(t, r, (o => o ? i(o) : n.preserveTimestamps ? function(e, t, r, n) { + if (function(e) { + return !(128 & e); + }(e)) { + return function(e, t, r) { + return ln(e, 128 | t, r); + }(r, e, (i => i ? n(i) : cn(e, t, r, n))); + } + return cn(e, t, r, n); + }(e.mode, t, r, i) : ln(r, e.mode, i))); +} + +function cn(e, t, r, n) { + !function(e, t, r) { + Qr.stat(e, ((e, n) => e ? r(e) : nn(t, n.atime, n.mtime, r))); + }(t, r, (t => t ? n(t) : ln(r, e, n))); +} + +function ln(e, t, r) { + return Qr.chmod(e, t, r); +} + +function fn(e, t, r, n) { + Qr.readdir(e, ((i, o) => i ? n(i) : dn(o, e, t, r, n))); +} + +function dn(e, t, r, n, i) { + const o = e.pop(); + return o ? function(e, t, r, n, i, o) { + const s = en.join(r, t), u = en.join(n, t); + sn(s, u, i, ((t, a) => t ? o(t) : a ? void on.checkPaths(s, u, "copy", i, ((t, a) => { + if (t) { + return o(t); + } + const {destStat: c} = a; + un(c, s, u, i, (t => t ? o(t) : dn(e, r, n, i, o))); + })) : dn(e, r, n, i, o))); + }(e, o, t, r, n, i) : i(); +} + +var pn = function(e, t, r, n) { + "function" != typeof r || n ? "function" == typeof r && (r = { + filter: r + }) : (n = r, r = {}), n = n || function() {}, (r = r || {}).clobber = !("clobber" in r) || !!r.clobber, + r.overwrite = "overwrite" in r ? !!r.overwrite : r.clobber, r.preserveTimestamps && "ia32" === process.arch && process.emitWarning("Using the preserveTimestamps option in 32-bit node is not recommended;\n\n\tsee https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0001"), + on.checkPaths(e, t, "copy", r, ((i, o) => { + if (i) { + return n(i); + } + const {srcStat: s, destStat: u} = o; + on.checkParentPaths(e, s, t, "copy", (i => { + if (i) { + return n(i); + } + sn(e, t, r, ((i, o) => i ? n(i) : o ? void function(e, t, r, n, i) { + const o = en.dirname(r); + rn(o, ((s, u) => s ? i(s) : u ? un(e, t, r, n, i) : void tn(o, (o => o ? i(o) : un(e, t, r, n, i))))); + }(u, e, t, r, n) : n())); + })); + })); +}; + +const hn = Fr, En = t, Dn = kr.mkdirsSync, mn = Vr, gn = Zr; + +function vn(e, t, r, n) { + const i = (n.dereference ? hn.statSync : hn.lstatSync)(t); + if (i.isDirectory()) { + return function(e, t, r, n, i) { + return t ? An(r, n, i) : function(e, t, r, n) { + return hn.mkdirSync(r), An(t, r, n), Cn(r, e); + }(e.mode, r, n, i); + }(i, e, t, r, n); + } + if (i.isFile() || i.isCharacterDevice() || i.isBlockDevice()) { + return function(e, t, r, n, i) { + return t ? function(e, t, r, n) { + if (n.overwrite) { + return hn.unlinkSync(r), yn(e, t, r, n); + } + if (n.errorOnExist) { + throw new Error(`'${r}' already exists`); + } + }(e, r, n, i) : yn(e, r, n, i); + }(i, e, t, r, n); + } + if (i.isSymbolicLink()) { + return function(e, t, r, n) { + let i = hn.readlinkSync(t); + n.dereference && (i = En.resolve(process.cwd(), i)); + if (e) { + let e; + try { + e = hn.readlinkSync(r); + } catch (e) { + if ("EINVAL" === e.code || "UNKNOWN" === e.code) { + return hn.symlinkSync(i, r); + } + throw e; + } + if (n.dereference && (e = En.resolve(process.cwd(), e)), gn.isSrcSubdir(i, e)) { + throw new Error(`Cannot copy '${i}' to a subdirectory of itself, '${e}'.`); + } + if (gn.isSrcSubdir(e, i)) { + throw new Error(`Cannot overwrite '${e}' with '${i}'.`); + } + return function(e, t) { + return hn.unlinkSync(t), hn.symlinkSync(e, t); + }(i, r); + } + return hn.symlinkSync(i, r); + }(e, t, r, n); + } + if (i.isSocket()) { + throw new Error(`Cannot copy a socket file: ${t}`); + } + if (i.isFIFO()) { + throw new Error(`Cannot copy a FIFO pipe: ${t}`); + } + throw new Error(`Unknown file: ${t}`); +} + +function yn(e, t, r, n) { + return hn.copyFileSync(t, r), n.preserveTimestamps && function(e, t, r) { + (function(e) { + return !(128 & e); + })(e) && function(e, t) { + Cn(e, 128 | t); + }(r, e); + (function(e, t) { + const r = hn.statSync(e); + mn(t, r.atime, r.mtime); + })(t, r); + }(e.mode, t, r), Cn(r, e.mode); +} + +function Cn(e, t) { + return hn.chmodSync(e, t); +} + +function An(e, t, r) { + hn.readdirSync(e).forEach((n => function(e, t, r, n) { + const i = En.join(t, e), o = En.join(r, e); + if (n.filter && !n.filter(i, o)) { + return; + } + const {destStat: s} = gn.checkPathsSync(i, o, "copy", n); + return vn(s, i, o, n); + }(n, e, t, r))); +} + +var Fn = function(e, t, r) { + "function" == typeof r && (r = { + filter: r + }), (r = r || {}).clobber = !("clobber" in r) || !!r.clobber, r.overwrite = "overwrite" in r ? !!r.overwrite : r.clobber, + r.preserveTimestamps && "ia32" === process.arch && process.emitWarning("Using the preserveTimestamps option in 32-bit node is not recommended;\n\n\tsee https://github.com/jprichardson/node-fs-extra/issues/269", "Warning", "fs-extra-WARN0002"); + const {srcStat: n, destStat: i} = gn.checkPathsSync(e, t, "copy", r); + if (gn.checkParentPathsSync(e, n, t, "copy"), r.filter && !r.filter(e, t)) { + return; + } + const o = En.dirname(t); + return hn.existsSync(o) || Dn(o), vn(i, e, t, r); +}; + +var Sn = { + copy: (0, tr.fromCallback)(pn), + copySync: Fn +}; + +const On = Fr; + +var wn = { + remove: (0, tr.fromCallback)((function(e, t) { + On.rm(e, { + recursive: !0, + force: !0 + }, t); + })), + removeSync: function(e) { + On.rmSync(e, { + recursive: !0, + force: !0 + }); + } +}; + +const _n = tr.fromPromise, In = er, bn = t, Rn = kr, Pn = wn, Nn = _n((async function(e) { + let t; + try { + t = await In.readdir(e); + } catch { + return Rn.mkdirs(e); + } + return Promise.all(t.map((t => Pn.remove(bn.join(e, t))))); +})); + +function Tn(e) { + let t; + try { + t = In.readdirSync(e); + } catch { + return Rn.mkdirsSync(e); + } + t.forEach((t => { + t = bn.join(e, t), Pn.removeSync(t); + })); +} + +var Ln = { + emptyDirSync: Tn, + emptydirSync: Tn, + emptyDir: Nn, + emptydir: Nn +}; + +const Mn = tr.fromCallback, Bn = t, xn = Fr, kn = kr; + +var $n = { + createFile: Mn((function(e, t) { + function r() { + xn.writeFile(e, "", (e => { + if (e) { + return t(e); + } + t(); + })); + } + xn.stat(e, ((n, i) => { + if (!n && i.isFile()) { + return t(); + } + const o = Bn.dirname(e); + xn.stat(o, ((e, n) => { + if (e) { + return "ENOENT" === e.code ? kn.mkdirs(o, (e => { + if (e) { + return t(e); + } + r(); + })) : t(e); + } + n.isDirectory() ? r() : xn.readdir(o, (e => { + if (e) { + return t(e); + } + })); + })); + })); + })), + createFileSync: function(e) { + let t; + try { + t = xn.statSync(e); + } catch {} + if (t && t.isFile()) { + return; + } + const r = Bn.dirname(e); + try { + xn.statSync(r).isDirectory() || xn.readdirSync(r); + } catch (e) { + if (!e || "ENOENT" !== e.code) { + throw e; + } + kn.mkdirsSync(r); + } + xn.writeFileSync(e, ""); + } +}; + +const jn = tr.fromCallback, Hn = t, Gn = Fr, Un = kr, Vn = Hr.pathExists, {areIdentical: Jn} = Zr; + +var Wn = { + createLink: jn((function(e, t, r) { + function n(e, t) { + Gn.link(e, t, (e => { + if (e) { + return r(e); + } + r(null); + })); + } + Gn.lstat(t, ((i, o) => { + Gn.lstat(e, ((i, s) => { + if (i) { + return i.message = i.message.replace("lstat", "ensureLink"), r(i); + } + if (o && Jn(s, o)) { + return r(null); + } + const u = Hn.dirname(t); + Vn(u, ((i, o) => i ? r(i) : o ? n(e, t) : void Un.mkdirs(u, (i => { + if (i) { + return r(i); + } + n(e, t); + })))); + })); + })); + })), + createLinkSync: function(e, t) { + let r; + try { + r = Gn.lstatSync(t); + } catch {} + try { + const t = Gn.lstatSync(e); + if (r && Jn(t, r)) { + return; + } + } catch (e) { + throw e.message = e.message.replace("lstat", "ensureLink"), e; + } + const n = Hn.dirname(t); + return Gn.existsSync(n) || Un.mkdirsSync(n), Gn.linkSync(e, t); + } +}; + +const zn = t, Kn = Fr, Xn = Hr.pathExists; + +var Yn = { + symlinkPaths: function(e, t, r) { + if (zn.isAbsolute(e)) { + return Kn.lstat(e, (t => t ? (t.message = t.message.replace("lstat", "ensureSymlink"), + r(t)) : r(null, { + toCwd: e, + toDst: e + }))); + } + { + const n = zn.dirname(t), i = zn.join(n, e); + return Xn(i, ((t, o) => t ? r(t) : o ? r(null, { + toCwd: i, + toDst: e + }) : Kn.lstat(e, (t => t ? (t.message = t.message.replace("lstat", "ensureSymlink"), + r(t)) : r(null, { + toCwd: e, + toDst: zn.relative(n, e) + }))))); + } + }, + symlinkPathsSync: function(e, t) { + let r; + if (zn.isAbsolute(e)) { + if (r = Kn.existsSync(e), !r) { + throw new Error("absolute srcpath does not exist"); + } + return { + toCwd: e, + toDst: e + }; + } + { + const n = zn.dirname(t), i = zn.join(n, e); + if (r = Kn.existsSync(i), r) { + return { + toCwd: i, + toDst: e + }; + } + if (r = Kn.existsSync(e), !r) { + throw new Error("relative srcpath does not exist"); + } + return { + toCwd: e, + toDst: zn.relative(n, e) + }; + } + } +}; + +const qn = Fr; + +var Zn = { + symlinkType: function(e, t, r) { + if (r = "function" == typeof t ? t : r, t = "function" != typeof t && t) { + return r(null, t); + } + qn.lstat(e, ((e, n) => { + if (e) { + return r(null, "file"); + } + t = n && n.isDirectory() ? "dir" : "file", r(null, t); + })); + }, + symlinkTypeSync: function(e, t) { + let r; + if (t) { + return t; + } + try { + r = qn.lstatSync(e); + } catch { + return "file"; + } + return r && r.isDirectory() ? "dir" : "file"; + } +}; + +const Qn = tr.fromCallback, ei = t, ti = er, ri = kr.mkdirs, ni = kr.mkdirsSync, ii = Yn.symlinkPaths, oi = Yn.symlinkPathsSync, si = Zn.symlinkType, ui = Zn.symlinkTypeSync, ai = Hr.pathExists, {areIdentical: ci} = Zr; + +function li(e, t, r, n) { + ii(e, t, ((i, o) => { + if (i) { + return n(i); + } + e = o.toDst, si(o.toCwd, r, ((r, i) => { + if (r) { + return n(r); + } + const o = ei.dirname(t); + ai(o, ((r, s) => r ? n(r) : s ? ti.symlink(e, t, i, n) : void ri(o, (r => { + if (r) { + return n(r); + } + ti.symlink(e, t, i, n); + })))); + })); + })); +} + +var fi = { + createSymlink: Qn((function(e, t, r, n) { + n = "function" == typeof r ? r : n, r = "function" != typeof r && r, ti.lstat(t, ((i, o) => { + !i && o.isSymbolicLink() ? Promise.all([ ti.stat(e), ti.stat(t) ]).then((([i, o]) => { + if (ci(i, o)) { + return n(null); + } + li(e, t, r, n); + })) : li(e, t, r, n); + })); + })), + createSymlinkSync: function(e, t, r) { + let n; + try { + n = ti.lstatSync(t); + } catch {} + if (n && n.isSymbolicLink()) { + const r = ti.statSync(e), n = ti.statSync(t); + if (ci(r, n)) { + return; + } + } + const i = oi(e, t); + e = i.toDst, r = ui(i.toCwd, r); + const o = ei.dirname(t); + return ti.existsSync(o) || ni(o), ti.symlinkSync(e, t, r); + } +}; + +const {createFile: di, createFileSync: pi} = $n, {createLink: hi, createLinkSync: Ei} = Wn, {createSymlink: Di, createSymlinkSync: mi} = fi; + +var gi = { + createFile: di, + createFileSync: pi, + ensureFile: di, + ensureFileSync: pi, + createLink: hi, + createLinkSync: Ei, + ensureLink: hi, + ensureLinkSync: Ei, + createSymlink: Di, + createSymlinkSync: mi, + ensureSymlink: Di, + ensureSymlinkSync: mi +}; + +var vi = { + stringify: function(e, {EOL: t = "\n", finalEOL: r = !0, replacer: n = null, spaces: i} = {}) { + const o = r ? t : ""; + return JSON.stringify(e, n, i).replace(/\n/g, t) + o; + }, + stripBom: function(e) { + return Buffer.isBuffer(e) && (e = e.toString("utf8")), e.replace(/^\uFEFF/, ""); + } +}; + +let yi; + +try { + yi = Fr; +} catch (t) { + yi = e; +} + +const Ci = tr, {stringify: Ai, stripBom: Fi} = vi; + +const Si = Ci.fromPromise((async function(e, t = {}) { + "string" == typeof t && (t = { + encoding: t + }); + const r = t.fs || yi, n = !("throws" in t) || t.throws; + let i, o = await Ci.fromCallback(r.readFile)(e, t); + o = Fi(o); + try { + i = JSON.parse(o, t ? t.reviver : null); + } catch (t) { + if (n) { + throw t.message = `${e}: ${t.message}`, t; + } + return null; + } + return i; +})); + +const Oi = Ci.fromPromise((async function(e, t, r = {}) { + const n = r.fs || yi, i = Ai(t, r); + await Ci.fromCallback(n.writeFile)(e, i, r); +})); + +const wi = { + readFile: Si, + readFileSync: function(e, t = {}) { + "string" == typeof t && (t = { + encoding: t + }); + const r = t.fs || yi, n = !("throws" in t) || t.throws; + try { + let n = r.readFileSync(e, t); + return n = Fi(n), JSON.parse(n, t.reviver); + } catch (t) { + if (n) { + throw t.message = `${e}: ${t.message}`, t; + } + return null; + } + }, + writeFile: Oi, + writeFileSync: function(e, t, r = {}) { + const n = r.fs || yi, i = Ai(t, r); + return n.writeFileSync(e, i, r); + } +}; + +var _i = { + readJson: wi.readFile, + readJsonSync: wi.readFileSync, + writeJson: wi.writeFile, + writeJsonSync: wi.writeFileSync +}; + +const Ii = tr.fromCallback, bi = Fr, Ri = t, Pi = kr, Ni = Hr.pathExists; + +var Ti = { + outputFile: Ii((function(e, t, r, n) { + "function" == typeof r && (n = r, r = "utf8"); + const i = Ri.dirname(e); + Ni(i, ((o, s) => o ? n(o) : s ? bi.writeFile(e, t, r, n) : void Pi.mkdirs(i, (i => { + if (i) { + return n(i); + } + bi.writeFile(e, t, r, n); + })))); + })), + outputFileSync: function(e, ...t) { + const r = Ri.dirname(e); + if (bi.existsSync(r)) { + return bi.writeFileSync(e, ...t); + } + Pi.mkdirsSync(r), bi.writeFileSync(e, ...t); + } +}; + +const {stringify: Li} = vi, {outputFile: Mi} = Ti; + +var Bi = async function(e, t, r = {}) { + const n = Li(t, r); + await Mi(e, n, r); +}; + +const {stringify: xi} = vi, {outputFileSync: ki} = Ti; + +var $i = function(e, t, r) { + const n = xi(t, r); + ki(e, n, r); +}; + +const ji = tr.fromPromise, Hi = _i; + +Hi.outputJson = ji(Bi), Hi.outputJsonSync = $i, Hi.outputJSON = Hi.outputJson, Hi.outputJSONSync = Hi.outputJsonSync, +Hi.writeJSON = Hi.writeJson, Hi.writeJSONSync = Hi.writeJsonSync, Hi.readJSON = Hi.readJson, +Hi.readJSONSync = Hi.readJsonSync; + +var Gi = Hi; + +const Ui = Fr, Vi = t, Ji = Sn.copy, Wi = wn.remove, zi = kr.mkdirp, Ki = Hr.pathExists, Xi = Zr; + +function Yi(e, t, r, n, i) { + return n ? qi(e, t, r, i) : r ? Wi(t, (n => n ? i(n) : qi(e, t, r, i))) : void Ki(t, ((n, o) => n ? i(n) : o ? i(new Error("dest already exists.")) : qi(e, t, r, i))); +} + +function qi(e, t, r, n) { + Ui.rename(e, t, (i => i ? "EXDEV" !== i.code ? n(i) : function(e, t, r, n) { + const i = { + overwrite: r, + errorOnExist: !0 + }; + Ji(e, t, i, (t => t ? n(t) : Wi(e, n))); + }(e, t, r, n) : n())); +} + +var Zi = function(e, t, r, n) { + "function" == typeof r && (n = r, r = {}); + const i = (r = r || {}).overwrite || r.clobber || !1; + Xi.checkPaths(e, t, "move", r, ((r, o) => { + if (r) { + return n(r); + } + const {srcStat: s, isChangingCase: u = !1} = o; + Xi.checkParentPaths(e, s, t, "move", (r => r ? n(r) : function(e) { + const t = Vi.dirname(e); + return Vi.parse(t).root === t; + }(t) ? Yi(e, t, i, u, n) : void zi(Vi.dirname(t), (r => r ? n(r) : Yi(e, t, i, u, n))))); + })); +}; + +const Qi = Fr, eo = t, to = Sn.copySync, ro = wn.removeSync, no = kr.mkdirpSync, io = Zr; + +function oo(e, t, r) { + try { + Qi.renameSync(e, t); + } catch (n) { + if ("EXDEV" !== n.code) { + throw n; + } + return function(e, t, r) { + const n = { + overwrite: r, + errorOnExist: !0 + }; + return to(e, t, n), ro(e); + }(e, t, r); + } +} + +var so = function(e, t, r) { + const n = (r = r || {}).overwrite || r.clobber || !1, {srcStat: i, isChangingCase: o = !1} = io.checkPathsSync(e, t, "move", r); + return io.checkParentPathsSync(e, i, t, "move"), function(e) { + const t = eo.dirname(e); + return eo.parse(t).root === t; + }(t) || no(eo.dirname(t)), function(e, t, r, n) { + if (n) { + return oo(e, t, r); + } + if (r) { + return ro(t), oo(e, t, r); + } + if (Qi.existsSync(t)) { + throw new Error("dest already exists."); + } + return oo(e, t, r); + }(e, t, n, o); +}; + +var uo = { + move: (0, tr.fromCallback)(Zi), + moveSync: so +}, ao = { + ...er, + ...Sn, + ...Ln, + ...gi, + ...Gi, + ...kr, + ...uo, + ...Ti, + ...Hr, + ...wn +}; + +!function(e) { + var r = E && E.__importDefault || function(e) { + return e && e.__esModule ? e : { + default: e + }; + }; + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.getHvigorUserHomeCacheDir = void 0; + const i = r(ao), o = r(n), s = r(t), u = qt; + e.getHvigorUserHomeCacheDir = function() { + const e = s.default.resolve(o.default.homedir(), u.HVIGOR_USER_HOME_DIR_NAME), t = process.env.HVIGOR_USER_HOME; + return void 0 !== t && s.default.isAbsolute(t) ? (i.default.ensureDirSync(t), t) : e; + }; +}(Qt), function(e) { + var r = E && E.__importDefault || function(e) { + return e && e.__esModule ? e : { + default: e + }; + }; + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.ERROR_CODE_JSON_PATH = e.HVIGOR_PROJECT_WRAPPER_HOME = e.HVIGOR_PROJECT_ROOT_DIR = e.HVIGOR_PROJECT_CACHES_HOME = e.HVIGOR_PNPM_STORE_PATH = e.HVIGOR_WRAPPER_PNPM_SCRIPT_PATH = e.HVIGOR_WRAPPER_TOOLS_HOME = e.HVIGOR_USER_HOME = void 0; + const n = r(t), i = Qt, o = qt; + e.HVIGOR_USER_HOME = (0, i.getHvigorUserHomeCacheDir)(), e.HVIGOR_WRAPPER_TOOLS_HOME = n.default.resolve(e.HVIGOR_USER_HOME, "wrapper", "tools"), + e.HVIGOR_WRAPPER_PNPM_SCRIPT_PATH = n.default.resolve(e.HVIGOR_WRAPPER_TOOLS_HOME, "node_modules", ".bin", o.PNPM_TOOL), + e.HVIGOR_PNPM_STORE_PATH = n.default.resolve(e.HVIGOR_USER_HOME, "caches"), e.HVIGOR_PROJECT_CACHES_HOME = n.default.resolve(e.HVIGOR_USER_HOME, o.PROJECT_CACHES), + e.HVIGOR_PROJECT_ROOT_DIR = process.cwd(), e.HVIGOR_PROJECT_WRAPPER_HOME = n.default.resolve(e.HVIGOR_PROJECT_ROOT_DIR, o.HVIGOR), + e.ERROR_CODE_JSON_PATH = n.default.resolve(__dirname, "../../../res/errorcode.json"); +}(Zt); + +var co, lo, fo, po, ho, Eo = {}, Do = {}, mo = { + exports: {} +}, go = { + exports: {} +}; + +function vo() { + if (lo) { + return co; + } + lo = 1; + var e = 1e3, t = 60 * e, r = 60 * t, n = 24 * r, i = 7 * n, o = 365.25 * n; + function s(e, t, r, n) { + var i = t >= 1.5 * r; + return Math.round(e / r) + " " + n + (i ? "s" : ""); + } + return co = function(u, a) { + a = a || {}; + var c = typeof u; + if ("string" === c && u.length > 0) { + return function(s) { + if ((s = String(s)).length > 100) { + return; + } + var u = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(s); + if (!u) { + return; + } + var a = parseFloat(u[1]); + switch ((u[2] || "ms").toLowerCase()) { + case "years": + case "year": + case "yrs": + case "yr": + case "y": + return a * o; + + case "weeks": + case "week": + case "w": + return a * i; + + case "days": + case "day": + case "d": + return a * n; + + case "hours": + case "hour": + case "hrs": + case "hr": + case "h": + return a * r; + + case "minutes": + case "minute": + case "mins": + case "min": + case "m": + return a * t; + + case "seconds": + case "second": + case "secs": + case "sec": + case "s": + return a * e; + + case "milliseconds": + case "millisecond": + case "msecs": + case "msec": + case "ms": + return a; + + default: + return; + } + }(u); + } + if ("number" === c && isFinite(u)) { + return a.long ? function(i) { + var o = Math.abs(i); + if (o >= n) { + return s(i, o, n, "day"); + } + if (o >= r) { + return s(i, o, r, "hour"); + } + if (o >= t) { + return s(i, o, t, "minute"); + } + if (o >= e) { + return s(i, o, e, "second"); + } + return i + " ms"; + }(u) : function(i) { + var o = Math.abs(i); + if (o >= n) { + return Math.round(i / n) + "d"; + } + if (o >= r) { + return Math.round(i / r) + "h"; + } + if (o >= t) { + return Math.round(i / t) + "m"; + } + if (o >= e) { + return Math.round(i / e) + "s"; + } + return i + "ms"; + }(u); + } + throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(u)); + }; +} + +function yo() { + if (po) { + return fo; + } + return po = 1, fo = function(e) { + function t(e) { + let n, i, o, s = null; + function u(...e) { + if (!u.enabled) { + return; + } + const r = u, i = Number(new Date), o = i - (n || i); + r.diff = o, r.prev = n, r.curr = i, n = i, e[0] = t.coerce(e[0]), "string" != typeof e[0] && e.unshift("%O"); + let s = 0; + e[0] = e[0].replace(/%([a-zA-Z%])/g, ((n, i) => { + if ("%%" === n) { + return "%"; + } + s++; + const o = t.formatters[i]; + if ("function" == typeof o) { + const t = e[s]; + n = o.call(r, t), e.splice(s, 1), s--; + } + return n; + })), t.formatArgs.call(r, e); + (r.log || t.log).apply(r, e); + } + return u.namespace = e, u.useColors = t.useColors(), u.color = t.selectColor(e), + u.extend = r, u.destroy = t.destroy, Object.defineProperty(u, "enabled", { + enumerable: !0, + configurable: !1, + get: () => null !== s ? s : (i !== t.namespaces && (i = t.namespaces, o = t.enabled(e)), + o), + set: e => { + s = e; + } + }), "function" == typeof t.init && t.init(u), u; + } + function r(e, r) { + const n = t(this.namespace + (void 0 === r ? ":" : r) + e); + return n.log = this.log, n; + } + function n(e) { + return e.toString().substring(2, e.toString().length - 2).replace(/\.\*\?$/, "*"); + } + return t.debug = t, t.default = t, t.coerce = function(e) { + if (e instanceof Error) { + return e.stack || e.message; + } + return e; + }, t.disable = function() { + const e = [ ...t.names.map(n), ...t.skips.map(n).map((e => "-" + e)) ].join(","); + return t.enable(""), e; + }, t.enable = function(e) { + let r; + t.save(e), t.namespaces = e, t.names = [], t.skips = []; + const n = ("string" == typeof e ? e : "").split(/[\s,]+/), i = n.length; + for (r = 0; r < i; r++) { + n[r] && ("-" === (e = n[r].replace(/\*/g, ".*?"))[0] ? t.skips.push(new RegExp("^" + e.slice(1) + "$")) : t.names.push(new RegExp("^" + e + "$"))); + } + }, t.enabled = function(e) { + if ("*" === e[e.length - 1]) { + return !0; + } + let r, n; + for (r = 0, n = t.skips.length; r < n; r++) { + if (t.skips[r].test(e)) { + return !1; + } + } + for (r = 0, n = t.names.length; r < n; r++) { + if (t.names[r].test(e)) { + return !0; + } + } + return !1; + }, t.humanize = vo(), t.destroy = function() { + console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); + }, Object.keys(e).forEach((r => { + t[r] = e[r]; + })), t.names = [], t.skips = [], t.formatters = {}, t.selectColor = function(e) { + let r = 0; + for (let t = 0; t < e.length; t++) { + r = (r << 5) - r + e.charCodeAt(t), r |= 0; + } + return t.colors[Math.abs(r) % t.colors.length]; + }, t.enable(t.load()), t; + }, fo; +} + +var Co, Ao, Fo, So, Oo, wo = { + exports: {} +}; + +function _o() { + return Ao ? Co : (Ao = 1, Co = (e, t = process.argv) => { + const r = e.startsWith("-") ? "" : 1 === e.length ? "-" : "--", n = t.indexOf(r + e), i = t.indexOf("--"); + return -1 !== n && (-1 === i || n < i); + }); +} + +"undefined" == typeof process || "renderer" === process.type || !0 === process.browser || process.__nwjs ? mo.exports = (ho || (ho = 1, +function(e, t) { + t.formatArgs = function(t) { + if (t[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + t[0] + (this.useColors ? "%c " : " ") + "+" + e.exports.humanize(this.diff), + !this.useColors) { + return; + } + const r = "color: " + this.color; + t.splice(1, 0, r, "color: inherit"); + let n = 0, i = 0; + t[0].replace(/%[a-zA-Z%]/g, (e => { + "%%" !== e && (n++, "%c" === e && (i = n)); + })), t.splice(i, 0, r); + }, t.save = function(e) { + try { + e ? t.storage.setItem("debug", e) : t.storage.removeItem("debug"); + } catch (e) {} + }, t.load = function() { + let e; + try { + e = t.storage.getItem("debug"); + } catch (e) {} + return !e && "undefined" != typeof process && "env" in process && (e = process.env.DEBUG), + e; + }, t.useColors = function() { + return !("undefined" == typeof window || !window.process || "renderer" !== window.process.type && !window.process.__nwjs) || ("undefined" == typeof navigator || !navigator.userAgent || !navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) && ("undefined" != typeof document && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || "undefined" != typeof window && window.console && (window.console.firebug || window.console.exception && window.console.table) || "undefined" != typeof navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || "undefined" != typeof navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)); + }, t.storage = function() { + try { + return localStorage; + } catch (e) {} + }(), t.destroy = (() => { + let e = !1; + return () => { + e || (e = !0, console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.")); + }; + })(), t.colors = [ "#0000CC", "#0000FF", "#0033CC", "#0033FF", "#0066CC", "#0066FF", "#0099CC", "#0099FF", "#00CC00", "#00CC33", "#00CC66", "#00CC99", "#00CCCC", "#00CCFF", "#3300CC", "#3300FF", "#3333CC", "#3333FF", "#3366CC", "#3366FF", "#3399CC", "#3399FF", "#33CC00", "#33CC33", "#33CC66", "#33CC99", "#33CCCC", "#33CCFF", "#6600CC", "#6600FF", "#6633CC", "#6633FF", "#66CC00", "#66CC33", "#9900CC", "#9900FF", "#9933CC", "#9933FF", "#99CC00", "#99CC33", "#CC0000", "#CC0033", "#CC0066", "#CC0099", "#CC00CC", "#CC00FF", "#CC3300", "#CC3333", "#CC3366", "#CC3399", "#CC33CC", "#CC33FF", "#CC6600", "#CC6633", "#CC9900", "#CC9933", "#CCCC00", "#CCCC33", "#FF0000", "#FF0033", "#FF0066", "#FF0099", "#FF00CC", "#FF00FF", "#FF3300", "#FF3333", "#FF3366", "#FF3399", "#FF33CC", "#FF33FF", "#FF6600", "#FF6633", "#FF9900", "#FF9933", "#FFCC00", "#FFCC33" ], + t.log = console.debug || console.log || (() => {}), e.exports = yo()(t); + const {formatters: r} = e.exports; + r.j = function(e) { + try { + return JSON.stringify(e); + } catch (e) { + return "[UnexpectedJSONParseError]: " + e.message; + } + }; +}(go, go.exports)), go.exports) : mo.exports = (Oo || (Oo = 1, function(e, t) { + const r = c, i = u; + t.init = function(e) { + e.inspectOpts = {}; + const r = Object.keys(t.inspectOpts); + for (let n = 0; n < r.length; n++) { + e.inspectOpts[r[n]] = t.inspectOpts[r[n]]; + } + }, t.log = function(...e) { + return process.stderr.write(i.formatWithOptions(t.inspectOpts, ...e) + "\n"); + }, t.formatArgs = function(r) { + const {namespace: n, useColors: i} = this; + if (i) { + const t = this.color, i = "[3" + (t < 8 ? t : "8;5;" + t), o = ` ${i};1m${n} `; + r[0] = o + r[0].split("\n").join("\n" + o), r.push(i + "m+" + e.exports.humanize(this.diff) + ""); + } else { + r[0] = (t.inspectOpts.hideDate ? "" : (new Date).toISOString() + " ") + n + " " + r[0]; + } + }, t.save = function(e) { + e ? process.env.DEBUG = e : delete process.env.DEBUG; + }, t.load = function() { + return process.env.DEBUG; + }, t.useColors = function() { + return "colors" in t.inspectOpts ? Boolean(t.inspectOpts.colors) : r.isatty(process.stderr.fd); + }, t.destroy = i.deprecate((() => {}), "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."), + t.colors = [ 6, 2, 3, 4, 5, 1 ]; + try { + const e = function() { + if (So) { + return Fo; + } + So = 1; + const e = n, t = c, r = _o(), {env: i} = process; + let o; + function s(e) { + return 0 !== e && { + level: e, + hasBasic: !0, + has256: e >= 2, + has16m: e >= 3 + }; + } + function u(t, n) { + if (0 === o) { + return 0; + } + if (r("color=16m") || r("color=full") || r("color=truecolor")) { + return 3; + } + if (r("color=256")) { + return 2; + } + if (t && !n && void 0 === o) { + return 0; + } + const s = o || 0; + if ("dumb" === i.TERM) { + return s; + } + if ("win32" === process.platform) { + const t = e.release().split("."); + return Number(t[0]) >= 10 && Number(t[2]) >= 10586 ? Number(t[2]) >= 14931 ? 3 : 2 : 1; + } + if ("CI" in i) { + return [ "TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE" ].some((e => e in i)) || "codeship" === i.CI_NAME ? 1 : s; + } + if ("TEAMCITY_VERSION" in i) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(i.TEAMCITY_VERSION) ? 1 : 0; + } + if ("truecolor" === i.COLORTERM) { + return 3; + } + if ("TERM_PROGRAM" in i) { + const e = parseInt((i.TERM_PROGRAM_VERSION || "").split(".")[0], 10); + switch (i.TERM_PROGRAM) { + case "iTerm.app": + return e >= 3 ? 3 : 2; + + case "Apple_Terminal": + return 2; + } + } + return /-256(color)?$/i.test(i.TERM) ? 2 : /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(i.TERM) || "COLORTERM" in i ? 1 : s; + } + return r("no-color") || r("no-colors") || r("color=false") || r("color=never") ? o = 0 : (r("color") || r("colors") || r("color=true") || r("color=always")) && (o = 1), + "FORCE_COLOR" in i && (o = "true" === i.FORCE_COLOR ? 1 : "false" === i.FORCE_COLOR ? 0 : 0 === i.FORCE_COLOR.length ? 1 : Math.min(parseInt(i.FORCE_COLOR, 10), 3)), + Fo = { + supportsColor: function(e) { + return s(u(e, e && e.isTTY)); + }, + stdout: s(u(!0, t.isatty(1))), + stderr: s(u(!0, t.isatty(2))) + }; + }(); + e && (e.stderr || e).level >= 2 && (t.colors = [ 20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62, 63, 68, 69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112, 113, 128, 129, 134, 135, 148, 149, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 214, 215, 220, 221 ]); + } catch (e) {} + t.inspectOpts = Object.keys(process.env).filter((e => /^debug_/i.test(e))).reduce(((e, t) => { + const r = t.substring(6).toLowerCase().replace(/_([a-z])/g, ((e, t) => t.toUpperCase())); + let n = process.env[t]; + return n = !!/^(yes|on|true|enabled)$/i.test(n) || !/^(no|off|false|disabled)$/i.test(n) && ("null" === n ? null : Number(n)), + e[r] = n, e; + }), {}), e.exports = yo()(t); + const {formatters: o} = e.exports; + o.o = function(e) { + return this.inspectOpts.colors = this.useColors, i.inspect(e, this.inspectOpts).split("\n").map((e => e.trim())).join(" "); + }, o.O = function(e) { + return this.inspectOpts.colors = this.useColors, i.inspect(e, this.inspectOpts); + }; +}(wo, wo.exports)), wo.exports); + +var Io = mo.exports, bo = function(e) { + return (e = e || {}).circles ? function(e) { + var t = [], r = []; + return e.proto ? function e(i) { + if ("object" != typeof i || null === i) { + return i; + } + if (i instanceof Date) { + return new Date(i); + } + if (Array.isArray(i)) { + return n(i, e); + } + if (i instanceof Map) { + return new Map(n(Array.from(i), e)); + } + if (i instanceof Set) { + return new Set(n(Array.from(i), e)); + } + var o = {}; + for (var s in t.push(i), r.push(o), i) { + var u = i[s]; + if ("object" != typeof u || null === u) { + o[s] = u; + } else if (u instanceof Date) { + o[s] = new Date(u); + } else if (u instanceof Map) { + o[s] = new Map(n(Array.from(u), e)); + } else if (u instanceof Set) { + o[s] = new Set(n(Array.from(u), e)); + } else if (ArrayBuffer.isView(u)) { + o[s] = Ro(u); + } else { + var a = t.indexOf(u); + o[s] = -1 !== a ? r[a] : e(u); + } + } + return t.pop(), r.pop(), o; + } : function e(i) { + if ("object" != typeof i || null === i) { + return i; + } + if (i instanceof Date) { + return new Date(i); + } + if (Array.isArray(i)) { + return n(i, e); + } + if (i instanceof Map) { + return new Map(n(Array.from(i), e)); + } + if (i instanceof Set) { + return new Set(n(Array.from(i), e)); + } + var o = {}; + for (var s in t.push(i), r.push(o), i) { + if (!1 !== Object.hasOwnProperty.call(i, s)) { + var u = i[s]; + if ("object" != typeof u || null === u) { + o[s] = u; + } else if (u instanceof Date) { + o[s] = new Date(u); + } else if (u instanceof Map) { + o[s] = new Map(n(Array.from(u), e)); + } else if (u instanceof Set) { + o[s] = new Set(n(Array.from(u), e)); + } else if (ArrayBuffer.isView(u)) { + o[s] = Ro(u); + } else { + var a = t.indexOf(u); + o[s] = -1 !== a ? r[a] : e(u); + } + } + } + return t.pop(), r.pop(), o; + }; + function n(e, n) { + for (var i = Object.keys(e), o = new Array(i.length), s = 0; s < i.length; s++) { + var u = i[s], a = e[u]; + if ("object" != typeof a || null === a) { + o[u] = a; + } else if (a instanceof Date) { + o[u] = new Date(a); + } else if (ArrayBuffer.isView(a)) { + o[u] = Ro(a); + } else { + var c = t.indexOf(a); + o[u] = -1 !== c ? r[c] : n(a); + } + } + return o; + } + }(e) : e.proto ? function e(r) { + if ("object" != typeof r || null === r) { + return r; + } + if (r instanceof Date) { + return new Date(r); + } + if (Array.isArray(r)) { + return t(r, e); + } + if (r instanceof Map) { + return new Map(t(Array.from(r), e)); + } + if (r instanceof Set) { + return new Set(t(Array.from(r), e)); + } + var n = {}; + for (var i in r) { + var o = r[i]; + "object" != typeof o || null === o ? n[i] = o : o instanceof Date ? n[i] = new Date(o) : o instanceof Map ? n[i] = new Map(t(Array.from(o), e)) : o instanceof Set ? n[i] = new Set(t(Array.from(o), e)) : ArrayBuffer.isView(o) ? n[i] = Ro(o) : n[i] = e(o); + } + return n; + } : r; + function t(e, t) { + for (var r = Object.keys(e), n = new Array(r.length), i = 0; i < r.length; i++) { + var o = r[i], s = e[o]; + "object" != typeof s || null === s ? n[o] = s : s instanceof Date ? n[o] = new Date(s) : ArrayBuffer.isView(s) ? n[o] = Ro(s) : n[o] = t(s); + } + return n; + } + function r(e) { + if ("object" != typeof e || null === e) { + return e; + } + if (e instanceof Date) { + return new Date(e); + } + if (Array.isArray(e)) { + return t(e, r); + } + if (e instanceof Map) { + return new Map(t(Array.from(e), r)); + } + if (e instanceof Set) { + return new Set(t(Array.from(e), r)); + } + var n = {}; + for (var i in e) { + if (!1 !== Object.hasOwnProperty.call(e, i)) { + var o = e[i]; + "object" != typeof o || null === o ? n[i] = o : o instanceof Date ? n[i] = new Date(o) : o instanceof Map ? n[i] = new Map(t(Array.from(o), r)) : o instanceof Set ? n[i] = new Set(t(Array.from(o), r)) : ArrayBuffer.isView(o) ? n[i] = Ro(o) : n[i] = r(o); + } + } + return n; + } +}; + +function Ro(e) { + return e instanceof Buffer ? Buffer.from(e) : new e.constructor(e.buffer.slice(), e.byteOffset, e.length); +} + +const Po = u, No = Io("log4js:configuration"), To = [], Lo = [], Mo = e => !e, Bo = e => e && "object" == typeof e && !Array.isArray(e), xo = (e, t, r) => { + (Array.isArray(t) ? t : [ t ]).forEach((t => { + if (t) { + throw new Error(`Problem with log4js configuration: (${Po.inspect(e, { + depth: 5 + })}) - ${r}`); + } + })); +}; + +var ko = { + configure: e => { + No("New configuration to be validated: ", e), xo(e, Mo(Bo(e)), "must be an object."), + No(`Calling pre-processing listeners (${To.length})`), To.forEach((t => t(e))), + No("Configuration pre-processing finished."), No(`Calling configuration listeners (${Lo.length})`), + Lo.forEach((t => t(e))), No("Configuration finished."); + }, + addListener: e => { + Lo.push(e), No(`Added listener, now ${Lo.length} listeners`); + }, + addPreProcessingListener: e => { + To.push(e), No(`Added pre-processing listener, now ${To.length} listeners`); + }, + throwExceptionIf: xo, + anObject: Bo, + anInteger: e => e && "number" == typeof e && Number.isInteger(e), + validIdentifier: e => /^[A-Za-z][A-Za-z0-9_]*$/g.test(e), + not: Mo +}, $o = { + exports: {} +}; + +!function(e) { + function t(e, t) { + for (var r = e.toString(); r.length < t; ) { + r = "0" + r; + } + return r; + } + function r(e) { + return t(e, 2); + } + function n(n, i) { + "string" != typeof n && (i = n, n = e.exports.ISO8601_FORMAT), i || (i = e.exports.now()); + var o = r(i.getDate()), s = r(i.getMonth() + 1), u = r(i.getFullYear()), a = r(u.substring(2, 4)), c = n.indexOf("yyyy") > -1 ? u : a, l = r(i.getHours()), f = r(i.getMinutes()), d = r(i.getSeconds()), p = t(i.getMilliseconds(), 3), h = function(e) { + var t = Math.abs(e), r = String(Math.floor(t / 60)), n = String(t % 60); + return r = ("0" + r).slice(-2), n = ("0" + n).slice(-2), 0 === e ? "Z" : (e < 0 ? "+" : "-") + r + ":" + n; + }(i.getTimezoneOffset()); + return n.replace(/dd/g, o).replace(/MM/g, s).replace(/y{1,4}/g, c).replace(/hh/g, l).replace(/mm/g, f).replace(/ss/g, d).replace(/SSS/g, p).replace(/O/g, h); + } + function i(e, t, r, n) { + e["set" + (n ? "" : "UTC") + t](r); + } + e.exports = n, e.exports.asString = n, e.exports.parse = function(t, r, n) { + if (!t) { + throw new Error("pattern must be supplied"); + } + return function(t, r, n) { + var o = t.indexOf("O") < 0, s = !1, u = [ { + pattern: /y{1,4}/, + regexp: "\\d{1,4}", + fn: function(e, t) { + i(e, "FullYear", t, o); + } + }, { + pattern: /MM/, + regexp: "\\d{1,2}", + fn: function(e, t) { + i(e, "Month", t - 1, o), e.getMonth() !== t - 1 && (s = !0); + } + }, { + pattern: /dd/, + regexp: "\\d{1,2}", + fn: function(e, t) { + s && i(e, "Month", e.getMonth() - 1, o), i(e, "Date", t, o); + } + }, { + pattern: /hh/, + regexp: "\\d{1,2}", + fn: function(e, t) { + i(e, "Hours", t, o); + } + }, { + pattern: /mm/, + regexp: "\\d\\d", + fn: function(e, t) { + i(e, "Minutes", t, o); + } + }, { + pattern: /ss/, + regexp: "\\d\\d", + fn: function(e, t) { + i(e, "Seconds", t, o); + } + }, { + pattern: /SSS/, + regexp: "\\d\\d\\d", + fn: function(e, t) { + i(e, "Milliseconds", t, o); + } + }, { + pattern: /O/, + regexp: "[+-]\\d{1,2}:?\\d{2}?|Z", + fn: function(e, t) { + t = "Z" === t ? 0 : t.replace(":", ""); + var r = Math.abs(t), n = (t > 0 ? -1 : 1) * (r % 100 + 60 * Math.floor(r / 100)); + e.setUTCMinutes(e.getUTCMinutes() + n); + } + } ], a = u.reduce((function(e, t) { + return t.pattern.test(e.regexp) ? (t.index = e.regexp.match(t.pattern).index, e.regexp = e.regexp.replace(t.pattern, "(" + t.regexp + ")")) : t.index = -1, + e; + }), { + regexp: t, + index: [] + }), c = u.filter((function(e) { + return e.index > -1; + })); + c.sort((function(e, t) { + return e.index - t.index; + })); + var l = new RegExp(a.regexp).exec(r); + if (l) { + var f = n || e.exports.now(); + return c.forEach((function(e, t) { + e.fn(f, l[t + 1]); + })), f; + } + throw new Error("String '" + r + "' could not be parsed as '" + t + "'"); + }(t, r, n); + }, e.exports.now = function() { + return new Date; + }, e.exports.ISO8601_FORMAT = "yyyy-MM-ddThh:mm:ss.SSS", e.exports.ISO8601_WITH_TZ_OFFSET_FORMAT = "yyyy-MM-ddThh:mm:ss.SSSO", + e.exports.DATETIME_FORMAT = "dd MM yyyy hh:mm:ss.SSS", e.exports.ABSOLUTETIME_FORMAT = "hh:mm:ss.SSS"; +}($o); + +var jo = $o.exports; + +const Ho = jo, Go = n, Uo = u, Vo = t, Jo = l, Wo = Io("log4js:layouts"), zo = { + bold: [ 1, 22 ], + italic: [ 3, 23 ], + underline: [ 4, 24 ], + inverse: [ 7, 27 ], + white: [ 37, 39 ], + grey: [ 90, 39 ], + black: [ 90, 39 ], + blue: [ 34, 39 ], + cyan: [ 36, 39 ], + green: [ 32, 39 ], + magenta: [ 35, 39 ], + red: [ 91, 39 ], + yellow: [ 33, 39 ] +}; + +function Ko(e) { + return e ? `[${zo[e][0]}m` : ""; +} + +function Xo(e) { + return e ? `[${zo[e][1]}m` : ""; +} + +function Yo(e, t) { + return r = Uo.format("[%s] [%s] %s - ", Ho.asString(e.startTime), e.level.toString(), e.categoryName), + Ko(n = t) + r + Xo(n); + var r, n; +} + +function qo(e) { + return Yo(e) + Uo.format(...e.data); +} + +function Zo(e) { + return Yo(e, e.level.colour) + Uo.format(...e.data); +} + +function Qo(e) { + return Uo.format(...e.data); +} + +function es(e) { + return e.data[0]; +} + +function ts(e, t) { + const r = /%(-?[0-9]+)?(\.?-?[0-9]+)?([[\]cdhmnprzxXyflosCMAF%])(\{([^}]+)\})?|([^%]+)/; + function n(e) { + return e && e.pid ? e.pid.toString() : process.pid.toString(); + } + e = e || "%r %p %c - %m%n"; + const i = { + c: function(e, t) { + let r = e.categoryName; + if (t) { + const e = parseInt(t, 10), n = r.split("."); + e < n.length && (r = n.slice(n.length - e).join(".")); + } + return r; + }, + d: function(e, t) { + let r = Ho.ISO8601_FORMAT; + if (t) { + switch (r = t, r) { + case "ISO8601": + case "ISO8601_FORMAT": + r = Ho.ISO8601_FORMAT; + break; + + case "ISO8601_WITH_TZ_OFFSET": + case "ISO8601_WITH_TZ_OFFSET_FORMAT": + r = Ho.ISO8601_WITH_TZ_OFFSET_FORMAT; + break; + + case "ABSOLUTE": + process.emitWarning("Pattern %d{ABSOLUTE} is deprecated in favor of %d{ABSOLUTETIME}. Please use %d{ABSOLUTETIME} instead.", "DeprecationWarning", "log4js-node-DEP0003"), + Wo("[log4js-node-DEP0003]", "DEPRECATION: Pattern %d{ABSOLUTE} is deprecated and replaced by %d{ABSOLUTETIME}."); + + case "ABSOLUTETIME": + case "ABSOLUTETIME_FORMAT": + r = Ho.ABSOLUTETIME_FORMAT; + break; + + case "DATE": + process.emitWarning("Pattern %d{DATE} is deprecated due to the confusion it causes when used. Please use %d{DATETIME} instead.", "DeprecationWarning", "log4js-node-DEP0004"), + Wo("[log4js-node-DEP0004]", "DEPRECATION: Pattern %d{DATE} is deprecated and replaced by %d{DATETIME}."); + + case "DATETIME": + case "DATETIME_FORMAT": + r = Ho.DATETIME_FORMAT; + } + } + return Ho.asString(r, e.startTime); + }, + h: function() { + return Go.hostname().toString(); + }, + m: function(e) { + return Uo.format(...e.data); + }, + n: function() { + return Go.EOL; + }, + p: function(e) { + return e.level.toString(); + }, + r: function(e) { + return Ho.asString("hh:mm:ss", e.startTime); + }, + "[": function(e) { + return Ko(e.level.colour); + }, + "]": function(e) { + return Xo(e.level.colour); + }, + y: function() { + return n(); + }, + z: n, + "%": function() { + return "%"; + }, + x: function(e, r) { + return void 0 !== t[r] ? "function" == typeof t[r] ? t[r](e) : t[r] : null; + }, + X: function(e, t) { + const r = e.context[t]; + return void 0 !== r ? "function" == typeof r ? r(e) : r : null; + }, + f: function(e, t) { + let r = e.fileName || ""; + if (r = function(e) { + const t = "file://"; + return e.startsWith(t) && ("function" == typeof Jo.fileURLToPath ? e = Jo.fileURLToPath(e) : (e = Vo.normalize(e.replace(new RegExp(`^${t}`), "")), + "win32" === process.platform && (e = e.startsWith("\\") ? e.slice(1) : Vo.sep + Vo.sep + e))), + e; + }(r), t) { + const e = parseInt(t, 10), n = r.split(Vo.sep); + n.length > e && (r = n.slice(-e).join(Vo.sep)); + } + return r; + }, + l: function(e) { + return e.lineNumber ? `${e.lineNumber}` : ""; + }, + o: function(e) { + return e.columnNumber ? `${e.columnNumber}` : ""; + }, + s: function(e) { + return e.callStack || ""; + }, + C: function(e) { + return e.className || ""; + }, + M: function(e) { + return e.functionName || ""; + }, + A: function(e) { + return e.functionAlias || ""; + }, + F: function(e) { + return e.callerName || ""; + } + }; + function o(e, t, r) { + return i[e](t, r); + } + function s(e, t, r) { + let n = e; + return n = function(e, t) { + let r; + return e ? (r = parseInt(e.slice(1), 10), r > 0 ? t.slice(0, r) : t.slice(r)) : t; + }(t, n), n = function(e, t) { + let r; + if (e) { + if ("-" === e.charAt(0)) { + for (r = parseInt(e.slice(1), 10); t.length < r; ) { + t += " "; + } + } else { + for (r = parseInt(e, 10); t.length < r; ) { + t = ` ${t}`; + } + } + } + return t; + }(r, n), n; + } + return function(t) { + let n, i = "", u = e; + for (;null !== (n = r.exec(u)); ) { + const e = n[1], r = n[2], a = n[3], c = n[5], l = n[6]; + if (l) { + i += l.toString(); + } else { + i += s(o(a, t, c), r, e); + } + u = u.slice(n.index + n[0].length); + } + return i; + }; +} + +const rs = { + messagePassThrough: () => Qo, + basic: () => qo, + colored: () => Zo, + coloured: () => Zo, + pattern: e => ts(e && e.pattern, e && e.tokens), + dummy: () => es +}; + +var ns = { + basicLayout: qo, + messagePassThroughLayout: Qo, + patternLayout: ts, + colouredLayout: Zo, + coloredLayout: Zo, + dummyLayout: es, + addLayout(e, t) { + rs[e] = t; + }, + layout: (e, t) => rs[e] && rs[e](t) +}; + +const is = ko, os = [ "white", "grey", "black", "blue", "cyan", "green", "magenta", "red", "yellow" ]; + +class ss { + constructor(e, t, r) { + this.level = e, this.levelStr = t, this.colour = r; + } + toString() { + return this.levelStr; + } + static getLevel(e, t) { + return e ? e instanceof ss ? e : (e instanceof Object && e.levelStr && (e = e.levelStr), + ss[e.toString().toUpperCase()] || t) : t; + } + static addLevels(e) { + if (e) { + Object.keys(e).forEach((t => { + const r = t.toUpperCase(); + ss[r] = new ss(e[t].value, r, e[t].colour); + const n = ss.levels.findIndex((e => e.levelStr === r)); + n > -1 ? ss.levels[n] = ss[r] : ss.levels.push(ss[r]); + })), ss.levels.sort(((e, t) => e.level - t.level)); + } + } + isLessThanOrEqualTo(e) { + return "string" == typeof e && (e = ss.getLevel(e)), this.level <= e.level; + } + isGreaterThanOrEqualTo(e) { + return "string" == typeof e && (e = ss.getLevel(e)), this.level >= e.level; + } + isEqualTo(e) { + return "string" == typeof e && (e = ss.getLevel(e)), this.level === e.level; + } +} + +ss.levels = [], ss.addLevels({ + ALL: { + value: Number.MIN_VALUE, + colour: "grey" + }, + TRACE: { + value: 5e3, + colour: "blue" + }, + DEBUG: { + value: 1e4, + colour: "cyan" + }, + INFO: { + value: 2e4, + colour: "green" + }, + WARN: { + value: 3e4, + colour: "yellow" + }, + ERROR: { + value: 4e4, + colour: "red" + }, + FATAL: { + value: 5e4, + colour: "magenta" + }, + MARK: { + value: 9007199254740992, + colour: "grey" + }, + OFF: { + value: Number.MAX_VALUE, + colour: "grey" + } +}), is.addListener((e => { + const t = e.levels; + if (t) { + is.throwExceptionIf(e, is.not(is.anObject(t)), "levels must be an object"); + Object.keys(t).forEach((r => { + is.throwExceptionIf(e, is.not(is.validIdentifier(r)), `level name "${r}" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)`), + is.throwExceptionIf(e, is.not(is.anObject(t[r])), `level "${r}" must be an object`), + is.throwExceptionIf(e, is.not(t[r].value), `level "${r}" must have a 'value' property`), + is.throwExceptionIf(e, is.not(is.anInteger(t[r].value)), `level "${r}".value must have an integer value`), + is.throwExceptionIf(e, is.not(t[r].colour), `level "${r}" must have a 'colour' property`), + is.throwExceptionIf(e, is.not(os.indexOf(t[r].colour) > -1), `level "${r}".colour must be one of ${os.join(", ")}`); + })); + } +})), is.addListener((e => { + ss.addLevels(e.levels); +})); + +var us = ss, as = { + exports: {} +}, cs = {}; + +const {parse: ls, stringify: fs} = JSON, {keys: ds} = Object, ps = String, hs = "string", Es = {}, Ds = "object", ms = (e, t) => t, gs = e => e instanceof ps ? ps(e) : e, vs = (e, t) => typeof t === hs ? new ps(t) : t, ys = (e, t, r, n) => { + const i = []; + for (let o = ds(r), {length: s} = o, u = 0; u < s; u++) { + const s = o[u], a = r[s]; + if (a instanceof ps) { + const o = e[a]; + typeof o !== Ds || t.has(o) ? r[s] = n.call(r, s, o) : (t.add(o), r[s] = Es, i.push({ + k: s, + a: [ e, t, o, n ] + })); + } else { + r[s] !== Es && (r[s] = n.call(r, s, a)); + } + } + for (let {length: e} = i, t = 0; t < e; t++) { + const {k: e, a: o} = i[t]; + r[e] = n.call(r, e, ys.apply(null, o)); + } + return r; +}, Cs = (e, t, r) => { + const n = ps(t.push(r) - 1); + return e.set(r, n), n; +}, As = (e, t) => { + const r = ls(e, vs).map(gs), n = r[0], i = t || ms, o = typeof n === Ds && n ? ys(r, new Set, n, i) : n; + return i.call({ + "": o + }, "", o); +}; + +cs.parse = As; + +const Fs = (e, t, r) => { + const n = t && typeof t === Ds ? (e, r) => "" === e || -1 < t.indexOf(e) ? r : void 0 : t || ms, i = new Map, o = [], s = []; + let u = +Cs(i, o, n.call({ + "": e + }, "", e)), a = !u; + for (;u < o.length; ) { + a = !0, s[u] = fs(o[u++], c, r); + } + return "[" + s.join(",") + "]"; + function c(e, t) { + if (a) { + return a = !a, t; + } + const r = n.call(this, e, t); + switch (typeof r) { + case Ds: + if (null === r) { + return r; + } + + case hs: + return i.get(r) || Cs(i, o, r); + } + return r; + } +}; + +cs.stringify = Fs; + +cs.toJSON = e => ls(Fs(e)); + +cs.fromJSON = e => As(fs(e)); + +const Ss = cs, Os = us; + +const ws = new class { + constructor() { + const e = { + __LOG4JS_undefined__: void 0, + __LOG4JS_NaN__: Number("abc"), + __LOG4JS_Infinity__: 1 / 0, + "__LOG4JS_-Infinity__": -1 / 0 + }; + this.deMap = e, this.serMap = {}, Object.keys(this.deMap).forEach((e => { + const t = this.deMap[e]; + this.serMap[t] = e; + })); + } + canSerialise(e) { + return "string" != typeof e && e in this.serMap; + } + serialise(e) { + return this.canSerialise(e) ? this.serMap[e] : e; + } + canDeserialise(e) { + return e in this.deMap; + } + deserialise(e) { + return this.canDeserialise(e) ? this.deMap[e] : e; + } +}; + +let _s = class { + constructor(e, t, r, n, i, o) { + if (this.startTime = new Date, this.categoryName = e, this.data = r, this.level = t, + this.context = Object.assign({}, n), this.pid = process.pid, this.error = o, void 0 !== i) { + if (!i || "object" != typeof i || Array.isArray(i)) { + throw new TypeError("Invalid location type passed to LoggingEvent constructor"); + } + this.constructor._getLocationKeys().forEach((e => { + void 0 !== i[e] && (this[e] = i[e]); + })); + } + } + static _getLocationKeys() { + return [ "fileName", "lineNumber", "columnNumber", "callStack", "className", "functionName", "functionAlias", "callerName" ]; + } + serialise() { + return Ss.stringify(this, ((e, t) => (t instanceof Error && (t = Object.assign({ + message: t.message, + stack: t.stack + }, t)), ws.serialise(t)))); + } + static deserialise(e) { + let t; + try { + const r = Ss.parse(e, ((e, t) => { + if (t && t.message && t.stack) { + const e = new Error(t); + Object.keys(t).forEach((r => { + e[r] = t[r]; + })), t = e; + } + return ws.deserialise(t); + })); + this._getLocationKeys().forEach((e => { + void 0 !== r[e] && (r.location || (r.location = {}), r.location[e] = r[e]); + })), t = new _s(r.categoryName, Os.getLevel(r.level.levelStr), r.data, r.context, r.location, r.error), + t.startTime = new Date(r.startTime), t.pid = r.pid, r.cluster && (t.cluster = r.cluster); + } catch (r) { + t = new _s("log4js", Os.ERROR, [ "Unable to parse log:", e, "because: ", r ]); + } + return t; + } +}; + +var Is = _s; + +const bs = Io("log4js:clustering"), Rs = Is, Ps = ko; + +let Ns = !1, Ts = null; + +try { + Ts = require("cluster"); +} catch (e) { + bs("cluster module not present"), Ns = !0; +} + +const Ls = []; + +let Ms = !1, Bs = "NODE_APP_INSTANCE"; + +const xs = () => Ms && "0" === process.env[Bs], ks = () => Ns || Ts && Ts.isMaster || xs(), $s = e => { + Ls.forEach((t => t(e))); +}, js = (e, t) => { + if (bs("cluster message received from worker ", e, ": ", t), e.topic && e.data && (t = e, + e = void 0), t && t.topic && "log4js:message" === t.topic) { + bs("received message: ", t.data); + const e = Rs.deserialise(t.data); + $s(e); + } +}; + +Ns || Ps.addListener((e => { + Ls.length = 0, ({pm2: Ms, disableClustering: Ns, pm2InstanceVar: Bs = "NODE_APP_INSTANCE"} = e), + bs(`clustering disabled ? ${Ns}`), bs(`cluster.isMaster ? ${Ts && Ts.isMaster}`), + bs(`pm2 enabled ? ${Ms}`), bs(`pm2InstanceVar = ${Bs}`), bs(`process.env[${Bs}] = ${process.env[Bs]}`), + Ms && process.removeListener("message", js), Ts && Ts.removeListener && Ts.removeListener("message", js), + Ns || e.disableClustering ? bs("Not listening for cluster messages, because clustering disabled.") : xs() ? (bs("listening for PM2 broadcast messages"), + process.on("message", js)) : Ts && Ts.isMaster ? (bs("listening for cluster messages"), + Ts.on("message", js)) : bs("not listening for messages, because we are not a master process"); +})); + +var Hs = { + onlyOnMaster: (e, t) => ks() ? e() : t, + isMaster: ks, + send: e => { + ks() ? $s(e) : (Ms || (e.cluster = { + workerId: Ts.worker.id, + worker: process.pid + }), process.send({ + topic: "log4js:message", + data: e.serialise() + })); + }, + onMessage: e => { + Ls.push(e); + } +}, Gs = {}; + +function Us(e) { + if ("number" == typeof e && Number.isInteger(e)) { + return e; + } + const t = { + K: 1024, + M: 1048576, + G: 1073741824 + }, r = Object.keys(t), n = e.slice(-1).toLocaleUpperCase(), i = e.slice(0, -1).trim(); + if (r.indexOf(n) < 0 || !Number.isInteger(Number(i))) { + throw Error(`maxLogSize: "${e}" is invalid`); + } + return i * t[n]; +} + +function Vs(e) { + return function(e, t) { + const r = Object.assign({}, t); + return Object.keys(e).forEach((n => { + r[n] && (r[n] = e[n](t[n])); + })), r; + }({ + maxLogSize: Us + }, e); +} + +const Js = { + dateFile: Vs, + file: Vs, + fileSync: Vs +}; + +Gs.modifyConfig = e => Js[e.type] ? Js[e.type](e) : e; + +var Ws = {}; + +const zs = console.log.bind(console); + +Ws.configure = function(e, t) { + let r = t.colouredLayout; + return e.layout && (r = t.layout(e.layout.type, e.layout)), function(e, t) { + return r => { + zs(e(r, t)); + }; + }(r, e.timezoneOffset); +}; + +var Ks = {}; + +Ks.configure = function(e, t) { + let r = t.colouredLayout; + return e.layout && (r = t.layout(e.layout.type, e.layout)), function(e, t) { + return r => { + process.stdout.write(`${e(r, t)}\n`); + }; + }(r, e.timezoneOffset); +}; + +var Xs = {}; + +Xs.configure = function(e, t) { + let r = t.colouredLayout; + return e.layout && (r = t.layout(e.layout.type, e.layout)), function(e, t) { + return r => { + process.stderr.write(`${e(r, t)}\n`); + }; + }(r, e.timezoneOffset); +}; + +var Ys = {}; + +Ys.configure = function(e, t, r, n) { + const i = r(e.appender); + return function(e, t, r, n) { + const i = n.getLevel(e), o = n.getLevel(t, n.FATAL); + return e => { + const t = e.level; + i.isLessThanOrEqualTo(t) && o.isGreaterThanOrEqualTo(t) && r(e); + }; + }(e.level, e.maxLevel, i, n); +}; + +var qs = {}; + +const Zs = Io("log4js:categoryFilter"); + +qs.configure = function(e, t, r) { + const n = r(e.appender); + return function(e, t) { + return "string" == typeof e && (e = [ e ]), r => { + Zs(`Checking ${r.categoryName} against ${e}`), -1 === e.indexOf(r.categoryName) && (Zs("Not excluded, sending to appender"), + t(r)); + }; + }(e.exclude, n); +}; + +var Qs = {}; + +const eu = Io("log4js:noLogFilter"); + +Qs.configure = function(e, t, r) { + const n = r(e.appender); + return function(e, t) { + return r => { + eu(`Checking data: ${r.data} against filters: ${e}`), "string" == typeof e && (e = [ e ]), + e = e.filter((e => null != e && "" !== e)); + const n = new RegExp(e.join("|"), "i"); + (0 === e.length || r.data.findIndex((e => n.test(e))) < 0) && (eu("Not excluded, sending to appender"), + t(r)); + }; + }(e.exclude, n); +}; + +var tu = {}, ru = { + exports: {} +}, nu = {}, iu = { + fromCallback: function(e) { + return Object.defineProperty((function() { + if ("function" != typeof arguments[arguments.length - 1]) { + return new Promise(((t, r) => { + arguments[arguments.length] = (e, n) => { + if (e) { + return r(e); + } + t(n); + }, arguments.length++, e.apply(this, arguments); + })); + } + e.apply(this, arguments); + }), "name", { + value: e.name + }); + }, + fromPromise: function(e) { + return Object.defineProperty((function() { + const t = arguments[arguments.length - 1]; + if ("function" != typeof t) { + return e.apply(this, arguments); + } + e.apply(this, arguments).then((e => t(null, e)), t); + }), "name", { + value: e.name + }); + } +}; + +!function(e) { + const t = iu.fromCallback, r = Fr, n = [ "access", "appendFile", "chmod", "chown", "close", "copyFile", "fchmod", "fchown", "fdatasync", "fstat", "fsync", "ftruncate", "futimes", "lchown", "lchmod", "link", "lstat", "mkdir", "mkdtemp", "open", "readFile", "readdir", "readlink", "realpath", "rename", "rmdir", "stat", "symlink", "truncate", "unlink", "utimes", "writeFile" ].filter((e => "function" == typeof r[e])); + Object.keys(r).forEach((t => { + "promises" !== t && (e[t] = r[t]); + })), n.forEach((n => { + e[n] = t(r[n]); + })), e.exists = function(e, t) { + return "function" == typeof t ? r.exists(e, t) : new Promise((t => r.exists(e, t))); + }, e.read = function(e, t, n, i, o, s) { + return "function" == typeof s ? r.read(e, t, n, i, o, s) : new Promise(((s, u) => { + r.read(e, t, n, i, o, ((e, t, r) => { + if (e) { + return u(e); + } + s({ + bytesRead: t, + buffer: r + }); + })); + })); + }, e.write = function(e, t, ...n) { + return "function" == typeof n[n.length - 1] ? r.write(e, t, ...n) : new Promise(((i, o) => { + r.write(e, t, ...n, ((e, t, r) => { + if (e) { + return o(e); + } + i({ + bytesWritten: t, + buffer: r + }); + })); + })); + }, "function" == typeof r.realpath.native && (e.realpath.native = t(r.realpath.native)); +}(nu); + +const ou = t; + +function su(e) { + return (e = ou.normalize(ou.resolve(e)).split(ou.sep)).length > 0 ? e[0] : null; +} + +const uu = /[<>:"|?*]/; + +var au = function(e) { + const t = su(e); + return e = e.replace(t, ""), uu.test(e); +}; + +const cu = Fr, lu = t, fu = au, du = parseInt("0777", 8); + +var pu = function e(t, r, n, i) { + if ("function" == typeof r ? (n = r, r = {}) : r && "object" == typeof r || (r = { + mode: r + }), "win32" === process.platform && fu(t)) { + const e = new Error(t + " contains invalid WIN32 path characters."); + return e.code = "EINVAL", n(e); + } + let o = r.mode; + const s = r.fs || cu; + void 0 === o && (o = du & ~process.umask()), i || (i = null), n = n || function() {}, + t = lu.resolve(t), s.mkdir(t, o, (o => { + if (!o) { + return n(null, i = i || t); + } + if ("ENOENT" === o.code) { + if (lu.dirname(t) === t) { + return n(o); + } + e(lu.dirname(t), r, ((i, o) => { + i ? n(i, o) : e(t, r, n, o); + })); + } else { + s.stat(t, ((e, t) => { + e || !t.isDirectory() ? n(o, i) : n(null, i); + })); + } + })); +}; + +const hu = Fr, Eu = t, Du = au, mu = parseInt("0777", 8); + +var gu = function e(t, r, n) { + r && "object" == typeof r || (r = { + mode: r + }); + let i = r.mode; + const o = r.fs || hu; + if ("win32" === process.platform && Du(t)) { + const e = new Error(t + " contains invalid WIN32 path characters."); + throw e.code = "EINVAL", e; + } + void 0 === i && (i = mu & ~process.umask()), n || (n = null), t = Eu.resolve(t); + try { + o.mkdirSync(t, i), n = n || t; + } catch (i) { + if ("ENOENT" === i.code) { + if (Eu.dirname(t) === t) { + throw i; + } + n = e(Eu.dirname(t), r, n), e(t, r, n); + } else { + let e; + try { + e = o.statSync(t); + } catch (e) { + throw i; + } + if (!e.isDirectory()) { + throw i; + } + } + } + return n; +}; + +const vu = (0, iu.fromCallback)(pu); + +var yu = { + mkdirs: vu, + mkdirsSync: gu, + mkdirp: vu, + mkdirpSync: gu, + ensureDir: vu, + ensureDirSync: gu +}; + +const Cu = Fr; + +var Au = function(e, t, r, n) { + Cu.open(e, "r+", ((e, i) => { + if (e) { + return n(e); + } + Cu.futimes(i, t, r, (e => { + Cu.close(i, (t => { + n && n(e || t); + })); + })); + })); +}, Fu = function(e, t, r) { + const n = Cu.openSync(e, "r+"); + return Cu.futimesSync(n, t, r), Cu.closeSync(n); +}; + +const Su = Fr, Ou = t, wu = 10, _u = 5, Iu = 0, bu = process.versions.node.split("."), Ru = Number.parseInt(bu[0], 10), Pu = Number.parseInt(bu[1], 10), Nu = Number.parseInt(bu[2], 10); + +function Tu() { + if (Ru > wu) { + return !0; + } + if (Ru === wu) { + if (Pu > _u) { + return !0; + } + if (Pu === _u && Nu >= Iu) { + return !0; + } + } + return !1; +} + +function Lu(e, t) { + const r = Ou.resolve(e).split(Ou.sep).filter((e => e)), n = Ou.resolve(t).split(Ou.sep).filter((e => e)); + return r.reduce(((e, t, r) => e && n[r] === t), !0); +} + +function Mu(e, t, r) { + return `Cannot ${r} '${e}' to a subdirectory of itself, '${t}'.`; +} + +var Bu, xu, ku = { + checkPaths: function(e, t, r, n) { + !function(e, t, r) { + Tu() ? Su.stat(e, { + bigint: !0 + }, ((e, n) => { + if (e) { + return r(e); + } + Su.stat(t, { + bigint: !0 + }, ((e, t) => e ? "ENOENT" === e.code ? r(null, { + srcStat: n, + destStat: null + }) : r(e) : r(null, { + srcStat: n, + destStat: t + }))); + })) : Su.stat(e, ((e, n) => { + if (e) { + return r(e); + } + Su.stat(t, ((e, t) => e ? "ENOENT" === e.code ? r(null, { + srcStat: n, + destStat: null + }) : r(e) : r(null, { + srcStat: n, + destStat: t + }))); + })); + }(e, t, ((i, o) => { + if (i) { + return n(i); + } + const {srcStat: s, destStat: u} = o; + return u && u.ino && u.dev && u.ino === s.ino && u.dev === s.dev ? n(new Error("Source and destination must not be the same.")) : s.isDirectory() && Lu(e, t) ? n(new Error(Mu(e, t, r))) : n(null, { + srcStat: s, + destStat: u + }); + })); + }, + checkPathsSync: function(e, t, r) { + const {srcStat: n, destStat: i} = function(e, t) { + let r, n; + r = Tu() ? Su.statSync(e, { + bigint: !0 + }) : Su.statSync(e); + try { + n = Tu() ? Su.statSync(t, { + bigint: !0 + }) : Su.statSync(t); + } catch (e) { + if ("ENOENT" === e.code) { + return { + srcStat: r, + destStat: null + }; + } + throw e; + } + return { + srcStat: r, + destStat: n + }; + }(e, t); + if (i && i.ino && i.dev && i.ino === n.ino && i.dev === n.dev) { + throw new Error("Source and destination must not be the same."); + } + if (n.isDirectory() && Lu(e, t)) { + throw new Error(Mu(e, t, r)); + } + return { + srcStat: n, + destStat: i + }; + }, + checkParentPaths: function e(t, r, n, i, o) { + const s = Ou.resolve(Ou.dirname(t)), u = Ou.resolve(Ou.dirname(n)); + if (u === s || u === Ou.parse(u).root) { + return o(); + } + Tu() ? Su.stat(u, { + bigint: !0 + }, ((s, a) => s ? "ENOENT" === s.code ? o() : o(s) : a.ino && a.dev && a.ino === r.ino && a.dev === r.dev ? o(new Error(Mu(t, n, i))) : e(t, r, u, i, o))) : Su.stat(u, ((s, a) => s ? "ENOENT" === s.code ? o() : o(s) : a.ino && a.dev && a.ino === r.ino && a.dev === r.dev ? o(new Error(Mu(t, n, i))) : e(t, r, u, i, o))); + }, + checkParentPathsSync: function e(t, r, n, i) { + const o = Ou.resolve(Ou.dirname(t)), s = Ou.resolve(Ou.dirname(n)); + if (s === o || s === Ou.parse(s).root) { + return; + } + let u; + try { + u = Tu() ? Su.statSync(s, { + bigint: !0 + }) : Su.statSync(s); + } catch (e) { + if ("ENOENT" === e.code) { + return; + } + throw e; + } + if (u.ino && u.dev && u.ino === r.ino && u.dev === r.dev) { + throw new Error(Mu(t, n, i)); + } + return e(t, r, s, i); + }, + isSrcSubdir: Lu +}; + +const $u = Fr, ju = t, Hu = yu.mkdirsSync, Gu = Fu, Uu = ku; + +function Vu(e, t, r, n) { + if (!n.filter || n.filter(t, r)) { + return function(e, t, r, n) { + const i = n.dereference ? $u.statSync : $u.lstatSync, o = i(t); + if (o.isDirectory()) { + return function(e, t, r, n, i) { + if (!t) { + return function(e, t, r, n) { + return $u.mkdirSync(r), Wu(t, r, n), $u.chmodSync(r, e.mode); + }(e, r, n, i); + } + if (t && !t.isDirectory()) { + throw new Error(`Cannot overwrite non-directory '${n}' with directory '${r}'.`); + } + return Wu(r, n, i); + }(o, e, t, r, n); + } + if (o.isFile() || o.isCharacterDevice() || o.isBlockDevice()) { + return function(e, t, r, n, i) { + return t ? function(e, t, r, n) { + if (n.overwrite) { + return $u.unlinkSync(r), Ju(e, t, r, n); + } + if (n.errorOnExist) { + throw new Error(`'${r}' already exists`); + } + }(e, r, n, i) : Ju(e, r, n, i); + }(o, e, t, r, n); + } + if (o.isSymbolicLink()) { + return function(e, t, r, n) { + let i = $u.readlinkSync(t); + n.dereference && (i = ju.resolve(process.cwd(), i)); + if (e) { + let e; + try { + e = $u.readlinkSync(r); + } catch (e) { + if ("EINVAL" === e.code || "UNKNOWN" === e.code) { + return $u.symlinkSync(i, r); + } + throw e; + } + if (n.dereference && (e = ju.resolve(process.cwd(), e)), Uu.isSrcSubdir(i, e)) { + throw new Error(`Cannot copy '${i}' to a subdirectory of itself, '${e}'.`); + } + if ($u.statSync(r).isDirectory() && Uu.isSrcSubdir(e, i)) { + throw new Error(`Cannot overwrite '${e}' with '${i}'.`); + } + return function(e, t) { + return $u.unlinkSync(t), $u.symlinkSync(e, t); + }(i, r); + } + return $u.symlinkSync(i, r); + }(e, t, r, n); + } + }(e, t, r, n); + } +} + +function Ju(e, t, r, n) { + return "function" == typeof $u.copyFileSync ? ($u.copyFileSync(t, r), $u.chmodSync(r, e.mode), + n.preserveTimestamps ? Gu(r, e.atime, e.mtime) : void 0) : function(e, t, r, n) { + const i = 65536, o = (xu ? Bu : (xu = 1, Bu = function(e) { + if ("function" == typeof Buffer.allocUnsafe) { + try { + return Buffer.allocUnsafe(e); + } catch (t) { + return new Buffer(e); + } + } + return new Buffer(e); + }))(i), s = $u.openSync(t, "r"), u = $u.openSync(r, "w", e.mode); + let a = 0; + for (;a < e.size; ) { + const e = $u.readSync(s, o, 0, i, a); + $u.writeSync(u, o, 0, e), a += e; + } + n.preserveTimestamps && $u.futimesSync(u, e.atime, e.mtime); + $u.closeSync(s), $u.closeSync(u); + }(e, t, r, n); +} + +function Wu(e, t, r) { + $u.readdirSync(e).forEach((n => function(e, t, r, n) { + const i = ju.join(t, e), o = ju.join(r, e), {destStat: s} = Uu.checkPathsSync(i, o, "copy"); + return Vu(s, i, o, n); + }(n, e, t, r))); +} + +var zu = function(e, t, r) { + "function" == typeof r && (r = { + filter: r + }), (r = r || {}).clobber = !("clobber" in r) || !!r.clobber, r.overwrite = "overwrite" in r ? !!r.overwrite : r.clobber, + r.preserveTimestamps && "ia32" === process.arch && console.warn("fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n\n see https://github.com/jprichardson/node-fs-extra/issues/269"); + const {srcStat: n, destStat: i} = Uu.checkPathsSync(e, t, "copy"); + return Uu.checkParentPathsSync(e, n, t, "copy"), function(e, t, r, n) { + if (n.filter && !n.filter(t, r)) { + return; + } + const i = ju.dirname(r); + $u.existsSync(i) || Hu(i); + return Vu(e, t, r, n); + }(i, e, t, r); +}, Ku = { + copySync: zu +}; + +const Xu = iu.fromPromise, Yu = nu; + +var qu = { + pathExists: Xu((function(e) { + return Yu.access(e).then((() => !0)).catch((() => !1)); + })), + pathExistsSync: Yu.existsSync +}; + +const Zu = Fr, Qu = t, ea = yu.mkdirs, ta = qu.pathExists, ra = Au, na = ku; + +function ia(e, t, r, n, i) { + const o = Qu.dirname(r); + ta(o, ((s, u) => s ? i(s) : u ? sa(e, t, r, n, i) : void ea(o, (o => o ? i(o) : sa(e, t, r, n, i))))); +} + +function oa(e, t, r, n, i, o) { + Promise.resolve(i.filter(r, n)).then((s => s ? e(t, r, n, i, o) : o()), (e => o(e))); +} + +function sa(e, t, r, n, i) { + return n.filter ? oa(ua, e, t, r, n, i) : ua(e, t, r, n, i); +} + +function ua(e, t, r, n, i) { + (n.dereference ? Zu.stat : Zu.lstat)(t, ((o, s) => o ? i(o) : s.isDirectory() ? function(e, t, r, n, i, o) { + if (!t) { + return function(e, t, r, n, i) { + Zu.mkdir(r, (o => { + if (o) { + return i(o); + } + la(t, r, n, (t => t ? i(t) : Zu.chmod(r, e.mode, i))); + })); + }(e, r, n, i, o); + } + if (t && !t.isDirectory()) { + return o(new Error(`Cannot overwrite non-directory '${n}' with directory '${r}'.`)); + } + return la(r, n, i, o); + }(s, e, t, r, n, i) : s.isFile() || s.isCharacterDevice() || s.isBlockDevice() ? function(e, t, r, n, i, o) { + return t ? function(e, t, r, n, i) { + if (!n.overwrite) { + return n.errorOnExist ? i(new Error(`'${r}' already exists`)) : i(); + } + Zu.unlink(r, (o => o ? i(o) : aa(e, t, r, n, i))); + }(e, r, n, i, o) : aa(e, r, n, i, o); + }(s, e, t, r, n, i) : s.isSymbolicLink() ? function(e, t, r, n, i) { + Zu.readlink(t, ((t, o) => t ? i(t) : (n.dereference && (o = Qu.resolve(process.cwd(), o)), + e ? void Zu.readlink(r, ((t, s) => t ? "EINVAL" === t.code || "UNKNOWN" === t.code ? Zu.symlink(o, r, i) : i(t) : (n.dereference && (s = Qu.resolve(process.cwd(), s)), + na.isSrcSubdir(o, s) ? i(new Error(`Cannot copy '${o}' to a subdirectory of itself, '${s}'.`)) : e.isDirectory() && na.isSrcSubdir(s, o) ? i(new Error(`Cannot overwrite '${s}' with '${o}'.`)) : function(e, t, r) { + Zu.unlink(t, (n => n ? r(n) : Zu.symlink(e, t, r))); + }(o, r, i)))) : Zu.symlink(o, r, i)))); + }(e, t, r, n, i) : void 0)); +} + +function aa(e, t, r, n, i) { + return "function" == typeof Zu.copyFile ? Zu.copyFile(t, r, (t => t ? i(t) : ca(e, r, n, i))) : function(e, t, r, n, i) { + const o = Zu.createReadStream(t); + o.on("error", (e => i(e))).once("open", (() => { + const t = Zu.createWriteStream(r, { + mode: e.mode + }); + t.on("error", (e => i(e))).on("open", (() => o.pipe(t))).once("close", (() => ca(e, r, n, i))); + })); + }(e, t, r, n, i); +} + +function ca(e, t, r, n) { + Zu.chmod(t, e.mode, (i => i ? n(i) : r.preserveTimestamps ? ra(t, e.atime, e.mtime, n) : n())); +} + +function la(e, t, r, n) { + Zu.readdir(e, ((i, o) => i ? n(i) : fa(o, e, t, r, n))); +} + +function fa(e, t, r, n, i) { + const o = e.pop(); + return o ? function(e, t, r, n, i, o) { + const s = Qu.join(r, t), u = Qu.join(n, t); + na.checkPaths(s, u, "copy", ((t, a) => { + if (t) { + return o(t); + } + const {destStat: c} = a; + sa(c, s, u, i, (t => t ? o(t) : fa(e, r, n, i, o))); + })); + }(e, o, t, r, n, i) : i(); +} + +var da = function(e, t, r, n) { + "function" != typeof r || n ? "function" == typeof r && (r = { + filter: r + }) : (n = r, r = {}), n = n || function() {}, (r = r || {}).clobber = !("clobber" in r) || !!r.clobber, + r.overwrite = "overwrite" in r ? !!r.overwrite : r.clobber, r.preserveTimestamps && "ia32" === process.arch && console.warn("fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n\n see https://github.com/jprichardson/node-fs-extra/issues/269"), + na.checkPaths(e, t, "copy", ((i, o) => { + if (i) { + return n(i); + } + const {srcStat: s, destStat: u} = o; + na.checkParentPaths(e, s, t, "copy", (i => i ? n(i) : r.filter ? oa(ia, u, e, t, r, n) : ia(u, e, t, r, n))); + })); +}; + +var pa = { + copy: (0, iu.fromCallback)(da) +}; + +const ha = Fr, Ea = t, Da = a, ma = "win32" === process.platform; + +function ga(e) { + [ "unlink", "chmod", "stat", "lstat", "rmdir", "readdir" ].forEach((t => { + e[t] = e[t] || ha[t], e[t += "Sync"] = e[t] || ha[t]; + })), e.maxBusyTries = e.maxBusyTries || 3; +} + +function va(e, t, r) { + let n = 0; + "function" == typeof t && (r = t, t = {}), Da(e, "rimraf: missing path"), Da.strictEqual(typeof e, "string", "rimraf: path should be a string"), + Da.strictEqual(typeof r, "function", "rimraf: callback function required"), Da(t, "rimraf: invalid options argument provided"), + Da.strictEqual(typeof t, "object", "rimraf: options should be object"), ga(t), ya(e, t, (function i(o) { + if (o) { + if (("EBUSY" === o.code || "ENOTEMPTY" === o.code || "EPERM" === o.code) && n < t.maxBusyTries) { + n++; + return setTimeout((() => ya(e, t, i)), 100 * n); + } + "ENOENT" === o.code && (o = null); + } + r(o); + })); +} + +function ya(e, t, r) { + Da(e), Da(t), Da("function" == typeof r), t.lstat(e, ((n, i) => n && "ENOENT" === n.code ? r(null) : n && "EPERM" === n.code && ma ? Ca(e, t, n, r) : i && i.isDirectory() ? Fa(e, t, n, r) : void t.unlink(e, (n => { + if (n) { + if ("ENOENT" === n.code) { + return r(null); + } + if ("EPERM" === n.code) { + return ma ? Ca(e, t, n, r) : Fa(e, t, n, r); + } + if ("EISDIR" === n.code) { + return Fa(e, t, n, r); + } + } + return r(n); + })))); +} + +function Ca(e, t, r, n) { + Da(e), Da(t), Da("function" == typeof n), r && Da(r instanceof Error), t.chmod(e, 438, (i => { + i ? n("ENOENT" === i.code ? null : r) : t.stat(e, ((i, o) => { + i ? n("ENOENT" === i.code ? null : r) : o.isDirectory() ? Fa(e, t, r, n) : t.unlink(e, n); + })); + })); +} + +function Aa(e, t, r) { + let n; + Da(e), Da(t), r && Da(r instanceof Error); + try { + t.chmodSync(e, 438); + } catch (e) { + if ("ENOENT" === e.code) { + return; + } + throw r; + } + try { + n = t.statSync(e); + } catch (e) { + if ("ENOENT" === e.code) { + return; + } + throw r; + } + n.isDirectory() ? Oa(e, t, r) : t.unlinkSync(e); +} + +function Fa(e, t, r, n) { + Da(e), Da(t), r && Da(r instanceof Error), Da("function" == typeof n), t.rmdir(e, (i => { + !i || "ENOTEMPTY" !== i.code && "EEXIST" !== i.code && "EPERM" !== i.code ? i && "ENOTDIR" === i.code ? n(r) : n(i) : function(e, t, r) { + Da(e), Da(t), Da("function" == typeof r), t.readdir(e, ((n, i) => { + if (n) { + return r(n); + } + let o, s = i.length; + if (0 === s) { + return t.rmdir(e, r); + } + i.forEach((n => { + va(Ea.join(e, n), t, (n => { + if (!o) { + return n ? r(o = n) : void (0 == --s && t.rmdir(e, r)); + } + })); + })); + })); + }(e, t, n); + })); +} + +function Sa(e, t) { + let r; + ga(t = t || {}), Da(e, "rimraf: missing path"), Da.strictEqual(typeof e, "string", "rimraf: path should be a string"), + Da(t, "rimraf: missing options"), Da.strictEqual(typeof t, "object", "rimraf: options should be object"); + try { + r = t.lstatSync(e); + } catch (r) { + if ("ENOENT" === r.code) { + return; + } + "EPERM" === r.code && ma && Aa(e, t, r); + } + try { + r && r.isDirectory() ? Oa(e, t, null) : t.unlinkSync(e); + } catch (r) { + if ("ENOENT" === r.code) { + return; + } + if ("EPERM" === r.code) { + return ma ? Aa(e, t, r) : Oa(e, t, r); + } + if ("EISDIR" !== r.code) { + throw r; + } + Oa(e, t, r); + } +} + +function Oa(e, t, r) { + Da(e), Da(t), r && Da(r instanceof Error); + try { + t.rmdirSync(e); + } catch (n) { + if ("ENOTDIR" === n.code) { + throw r; + } + if ("ENOTEMPTY" === n.code || "EEXIST" === n.code || "EPERM" === n.code) { + !function(e, t) { + if (Da(e), Da(t), t.readdirSync(e).forEach((r => Sa(Ea.join(e, r), t))), !ma) { + return t.rmdirSync(e, t); + } + { + const r = Date.now(); + do { + try { + return t.rmdirSync(e, t); + } catch (e) {} + } while (Date.now() - r < 500); + } + }(e, t); + } else if ("ENOENT" !== n.code) { + throw n; + } + } +} + +var wa = va; + +va.sync = Sa; + +const _a = wa; + +var Ia = { + remove: (0, iu.fromCallback)(_a), + removeSync: _a.sync +}; + +const ba = iu.fromCallback, Ra = Fr, Pa = t, Na = yu, Ta = Ia, La = ba((function(e, t) { + t = t || function() {}, Ra.readdir(e, ((r, n) => { + if (r) { + return Na.mkdirs(e, t); + } + n = n.map((t => Pa.join(e, t))), function e() { + const r = n.pop(); + if (!r) { + return t(); + } + Ta.remove(r, (r => { + if (r) { + return t(r); + } + e(); + })); + }(); + })); +})); + +function Ma(e) { + let t; + try { + t = Ra.readdirSync(e); + } catch (t) { + return Na.mkdirsSync(e); + } + t.forEach((t => { + t = Pa.join(e, t), Ta.removeSync(t); + })); +} + +var Ba = { + emptyDirSync: Ma, + emptydirSync: Ma, + emptyDir: La, + emptydir: La +}; + +const xa = iu.fromCallback, ka = t, $a = Fr, ja = yu, Ha = qu.pathExists; + +var Ga = { + createFile: xa((function(e, t) { + function r() { + $a.writeFile(e, "", (e => { + if (e) { + return t(e); + } + t(); + })); + } + $a.stat(e, ((n, i) => { + if (!n && i.isFile()) { + return t(); + } + const o = ka.dirname(e); + Ha(o, ((e, n) => e ? t(e) : n ? r() : void ja.mkdirs(o, (e => { + if (e) { + return t(e); + } + r(); + })))); + })); + })), + createFileSync: function(e) { + let t; + try { + t = $a.statSync(e); + } catch (e) {} + if (t && t.isFile()) { + return; + } + const r = ka.dirname(e); + $a.existsSync(r) || ja.mkdirsSync(r), $a.writeFileSync(e, ""); + } +}; + +const Ua = iu.fromCallback, Va = t, Ja = Fr, Wa = yu, za = qu.pathExists; + +var Ka = { + createLink: Ua((function(e, t, r) { + function n(e, t) { + Ja.link(e, t, (e => { + if (e) { + return r(e); + } + r(null); + })); + } + za(t, ((i, o) => i ? r(i) : o ? r(null) : void Ja.lstat(e, (i => { + if (i) { + return i.message = i.message.replace("lstat", "ensureLink"), r(i); + } + const o = Va.dirname(t); + za(o, ((i, s) => i ? r(i) : s ? n(e, t) : void Wa.mkdirs(o, (i => { + if (i) { + return r(i); + } + n(e, t); + })))); + })))); + })), + createLinkSync: function(e, t) { + if (Ja.existsSync(t)) { + return; + } + try { + Ja.lstatSync(e); + } catch (e) { + throw e.message = e.message.replace("lstat", "ensureLink"), e; + } + const r = Va.dirname(t); + return Ja.existsSync(r) || Wa.mkdirsSync(r), Ja.linkSync(e, t); + } +}; + +const Xa = t, Ya = Fr, qa = qu.pathExists; + +var Za = { + symlinkPaths: function(e, t, r) { + if (Xa.isAbsolute(e)) { + return Ya.lstat(e, (t => t ? (t.message = t.message.replace("lstat", "ensureSymlink"), + r(t)) : r(null, { + toCwd: e, + toDst: e + }))); + } + { + const n = Xa.dirname(t), i = Xa.join(n, e); + return qa(i, ((t, o) => t ? r(t) : o ? r(null, { + toCwd: i, + toDst: e + }) : Ya.lstat(e, (t => t ? (t.message = t.message.replace("lstat", "ensureSymlink"), + r(t)) : r(null, { + toCwd: e, + toDst: Xa.relative(n, e) + }))))); + } + }, + symlinkPathsSync: function(e, t) { + let r; + if (Xa.isAbsolute(e)) { + if (r = Ya.existsSync(e), !r) { + throw new Error("absolute srcpath does not exist"); + } + return { + toCwd: e, + toDst: e + }; + } + { + const n = Xa.dirname(t), i = Xa.join(n, e); + if (r = Ya.existsSync(i), r) { + return { + toCwd: i, + toDst: e + }; + } + if (r = Ya.existsSync(e), !r) { + throw new Error("relative srcpath does not exist"); + } + return { + toCwd: e, + toDst: Xa.relative(n, e) + }; + } + } +}; + +const Qa = Fr; + +var ec = { + symlinkType: function(e, t, r) { + if (r = "function" == typeof t ? t : r, t = "function" != typeof t && t) { + return r(null, t); + } + Qa.lstat(e, ((e, n) => { + if (e) { + return r(null, "file"); + } + t = n && n.isDirectory() ? "dir" : "file", r(null, t); + })); + }, + symlinkTypeSync: function(e, t) { + let r; + if (t) { + return t; + } + try { + r = Qa.lstatSync(e); + } catch (e) { + return "file"; + } + return r && r.isDirectory() ? "dir" : "file"; + } +}; + +const tc = iu.fromCallback, rc = t, nc = Fr, ic = yu.mkdirs, oc = yu.mkdirsSync, sc = Za.symlinkPaths, uc = Za.symlinkPathsSync, ac = ec.symlinkType, cc = ec.symlinkTypeSync, lc = qu.pathExists; + +var fc = { + createSymlink: tc((function(e, t, r, n) { + n = "function" == typeof r ? r : n, r = "function" != typeof r && r, lc(t, ((i, o) => i ? n(i) : o ? n(null) : void sc(e, t, ((i, o) => { + if (i) { + return n(i); + } + e = o.toDst, ac(o.toCwd, r, ((r, i) => { + if (r) { + return n(r); + } + const o = rc.dirname(t); + lc(o, ((r, s) => r ? n(r) : s ? nc.symlink(e, t, i, n) : void ic(o, (r => { + if (r) { + return n(r); + } + nc.symlink(e, t, i, n); + })))); + })); + })))); + })), + createSymlinkSync: function(e, t, r) { + if (nc.existsSync(t)) { + return; + } + const n = uc(e, t); + e = n.toDst, r = cc(n.toCwd, r); + const i = rc.dirname(t); + return nc.existsSync(i) || oc(i), nc.symlinkSync(e, t, r); + } +}; + +var dc, pc = { + createFile: Ga.createFile, + createFileSync: Ga.createFileSync, + ensureFile: Ga.createFile, + ensureFileSync: Ga.createFileSync, + createLink: Ka.createLink, + createLinkSync: Ka.createLinkSync, + ensureLink: Ka.createLink, + ensureLinkSync: Ka.createLinkSync, + createSymlink: fc.createSymlink, + createSymlinkSync: fc.createSymlinkSync, + ensureSymlink: fc.createSymlink, + ensureSymlinkSync: fc.createSymlinkSync +}; + +try { + dc = Fr; +} catch (t) { + dc = e; +} + +function hc(e, t) { + var r, n = "\n"; + return "object" == typeof t && null !== t && (t.spaces && (r = t.spaces), t.EOL && (n = t.EOL)), + JSON.stringify(e, t ? t.replacer : null, r).replace(/\n/g, n) + n; +} + +function Ec(e) { + return Buffer.isBuffer(e) && (e = e.toString("utf8")), e = e.replace(/^\uFEFF/, ""); +} + +var Dc = { + readFile: function(e, t, r) { + null == r && (r = t, t = {}), "string" == typeof t && (t = { + encoding: t + }); + var n = (t = t || {}).fs || dc, i = !0; + "throws" in t && (i = t.throws), n.readFile(e, t, (function(n, o) { + if (n) { + return r(n); + } + var s; + o = Ec(o); + try { + s = JSON.parse(o, t ? t.reviver : null); + } catch (t) { + return i ? (t.message = e + ": " + t.message, r(t)) : r(null, null); + } + r(null, s); + })); + }, + readFileSync: function(e, t) { + "string" == typeof (t = t || {}) && (t = { + encoding: t + }); + var r = t.fs || dc, n = !0; + "throws" in t && (n = t.throws); + try { + var i = r.readFileSync(e, t); + return i = Ec(i), JSON.parse(i, t.reviver); + } catch (t) { + if (n) { + throw t.message = e + ": " + t.message, t; + } + return null; + } + }, + writeFile: function(e, t, r, n) { + null == n && (n = r, r = {}); + var i = (r = r || {}).fs || dc, o = ""; + try { + o = hc(t, r); + } catch (e) { + return void (n && n(e, null)); + } + i.writeFile(e, o, r, n); + }, + writeFileSync: function(e, t, r) { + var n = (r = r || {}).fs || dc, i = hc(t, r); + return n.writeFileSync(e, i, r); + } +}, mc = Dc; + +const gc = iu.fromCallback, vc = mc; + +var yc = { + readJson: gc(vc.readFile), + readJsonSync: vc.readFileSync, + writeJson: gc(vc.writeFile), + writeJsonSync: vc.writeFileSync +}; + +const Cc = t, Ac = yu, Fc = qu.pathExists, Sc = yc; + +var Oc = function(e, t, r, n) { + "function" == typeof r && (n = r, r = {}); + const i = Cc.dirname(e); + Fc(i, ((o, s) => o ? n(o) : s ? Sc.writeJson(e, t, r, n) : void Ac.mkdirs(i, (i => { + if (i) { + return n(i); + } + Sc.writeJson(e, t, r, n); + })))); +}; + +const wc = Fr, _c = t, Ic = yu, bc = yc; + +var Rc = function(e, t, r) { + const n = _c.dirname(e); + wc.existsSync(n) || Ic.mkdirsSync(n), bc.writeJsonSync(e, t, r); +}; + +const Pc = iu.fromCallback, Nc = yc; + +Nc.outputJson = Pc(Oc), Nc.outputJsonSync = Rc, Nc.outputJSON = Nc.outputJson, Nc.outputJSONSync = Nc.outputJsonSync, +Nc.writeJSON = Nc.writeJson, Nc.writeJSONSync = Nc.writeJsonSync, Nc.readJSON = Nc.readJson, +Nc.readJSONSync = Nc.readJsonSync; + +var Tc = Nc; + +const Lc = Fr, Mc = t, Bc = Ku.copySync, xc = Ia.removeSync, kc = yu.mkdirpSync, $c = ku; + +function jc(e, t, r) { + try { + Lc.renameSync(e, t); + } catch (n) { + if ("EXDEV" !== n.code) { + throw n; + } + return function(e, t, r) { + const n = { + overwrite: r, + errorOnExist: !0 + }; + return Bc(e, t, n), xc(e); + }(e, t, r); + } +} + +var Hc = function(e, t, r) { + const n = (r = r || {}).overwrite || r.clobber || !1, {srcStat: i} = $c.checkPathsSync(e, t, "move"); + return $c.checkParentPathsSync(e, i, t, "move"), kc(Mc.dirname(t)), function(e, t, r) { + if (r) { + return xc(t), jc(e, t, r); + } + if (Lc.existsSync(t)) { + throw new Error("dest already exists."); + } + return jc(e, t, r); + }(e, t, n); +}, Gc = { + moveSync: Hc +}; + +const Uc = Fr, Vc = t, Jc = pa.copy, Wc = Ia.remove, zc = yu.mkdirp, Kc = qu.pathExists, Xc = ku; + +function Yc(e, t, r, n) { + Uc.rename(e, t, (i => i ? "EXDEV" !== i.code ? n(i) : function(e, t, r, n) { + const i = { + overwrite: r, + errorOnExist: !0 + }; + Jc(e, t, i, (t => t ? n(t) : Wc(e, n))); + }(e, t, r, n) : n())); +} + +var qc = function(e, t, r, n) { + "function" == typeof r && (n = r, r = {}); + const i = r.overwrite || r.clobber || !1; + Xc.checkPaths(e, t, "move", ((r, o) => { + if (r) { + return n(r); + } + const {srcStat: s} = o; + Xc.checkParentPaths(e, s, t, "move", (r => { + if (r) { + return n(r); + } + zc(Vc.dirname(t), (r => r ? n(r) : function(e, t, r, n) { + if (r) { + return Wc(t, (i => i ? n(i) : Yc(e, t, r, n))); + } + Kc(t, ((i, o) => i ? n(i) : o ? n(new Error("dest already exists.")) : Yc(e, t, r, n))); + }(e, t, i, n))); + })); + })); +}; + +var Zc = { + move: (0, iu.fromCallback)(qc) +}; + +const Qc = iu.fromCallback, el = Fr, tl = t, rl = yu, nl = qu.pathExists; + +var il = { + outputFile: Qc((function(e, t, r, n) { + "function" == typeof r && (n = r, r = "utf8"); + const i = tl.dirname(e); + nl(i, ((o, s) => o ? n(o) : s ? el.writeFile(e, t, r, n) : void rl.mkdirs(i, (i => { + if (i) { + return n(i); + } + el.writeFile(e, t, r, n); + })))); + })), + outputFileSync: function(e, ...t) { + const r = tl.dirname(e); + if (el.existsSync(r)) { + return el.writeFileSync(e, ...t); + } + rl.mkdirsSync(r), el.writeFileSync(e, ...t); + } +}; + +!function(t) { + t.exports = Object.assign({}, nu, Ku, pa, Ba, pc, Tc, yu, Gc, Zc, il, qu, Ia); + const r = e; + Object.getOwnPropertyDescriptor(r, "promises") && Object.defineProperty(t.exports, "promises", { + get: () => r.promises + }); +}(ru); + +var ol = ru.exports; + +const sl = Io("streamroller:fileNameFormatter"), ul = t; + +const al = Io("streamroller:fileNameParser"), cl = jo; + +const ll = Io("streamroller:moveAndMaybeCompressFile"), fl = ol, dl = f; + +var pl = async (e, t, r) => { + if (r = function(e) { + const t = { + mode: parseInt("0600", 8), + compress: !1 + }, r = Object.assign({}, t, e); + return ll(`_parseOption: moveAndMaybeCompressFile called with option=${JSON.stringify(r)}`), + r; + }(r), e !== t) { + if (await fl.pathExists(e)) { + if (ll(`moveAndMaybeCompressFile: moving file from ${e} to ${t} ${r.compress ? "with" : "without"} compress`), + r.compress) { + await new Promise(((n, i) => { + let o = !1; + const s = fl.createWriteStream(t, { + mode: r.mode, + flags: "wx" + }).on("open", (() => { + o = !0; + const t = fl.createReadStream(e).on("open", (() => { + t.pipe(dl.createGzip()).pipe(s); + })).on("error", (t => { + ll(`moveAndMaybeCompressFile: error reading ${e}`, t), s.destroy(t); + })); + })).on("finish", (() => { + ll(`moveAndMaybeCompressFile: finished compressing ${t}, deleting ${e}`), fl.unlink(e).then(n).catch((t => { + ll(`moveAndMaybeCompressFile: error deleting ${e}, truncating instead`, t), fl.truncate(e).then(n).catch((t => { + ll(`moveAndMaybeCompressFile: error truncating ${e}`, t), i(t); + })); + })); + })).on("error", (e => { + o ? (ll(`moveAndMaybeCompressFile: error writing ${t}, deleting`, e), fl.unlink(t).then((() => { + i(e); + })).catch((e => { + ll(`moveAndMaybeCompressFile: error deleting ${t}`, e), i(e); + }))) : (ll(`moveAndMaybeCompressFile: error creating ${t}`, e), i(e)); + })); + })).catch((() => {})); + } else { + ll(`moveAndMaybeCompressFile: renaming ${e} to ${t}`); + try { + await fl.move(e, t, { + overwrite: !0 + }); + } catch (r) { + if (ll(`moveAndMaybeCompressFile: error renaming ${e} to ${t}`, r), "ENOENT" !== r.code) { + ll("moveAndMaybeCompressFile: trying copy+truncate instead"); + try { + await fl.copy(e, t, { + overwrite: !0 + }), await fl.truncate(e); + } catch (e) { + ll("moveAndMaybeCompressFile: error copy+truncate", e); + } + } + } + } + } + } else { + ll("moveAndMaybeCompressFile: source and target are the same, not doing anything"); + } +}; + +const hl = Io("streamroller:RollingFileWriteStream"), El = ol, Dl = t, ml = n, gl = () => new Date, vl = jo, {Writable: yl} = s, Cl = ({file: e, keepFileExt: t, needsIndex: r, alwaysIncludeDate: n, compress: i, fileNameSep: o}) => { + let s = o || "."; + const u = ul.join(e.dir, e.name), a = t => t + e.ext, c = (e, t, n) => !r && n || !t ? e : e + s + t, l = (e, t, r) => (t > 0 || n) && r ? e + s + r : e, f = (e, t) => t && i ? e + ".gz" : e, d = t ? [ l, c, a, f ] : [ a, l, c, f ]; + return ({date: e, index: t}) => (sl(`_formatFileName: date=${e}, index=${t}`), d.reduce(((r, n) => n(r, t, e)), u)); +}, Al = ({file: e, keepFileExt: t, pattern: r, fileNameSep: n}) => { + let i = n || "."; + const o = "__NOT_MATCHING__"; + let s = [ (e, t) => e.endsWith(".gz") ? (al("it is gzipped"), t.isCompressed = !0, + e.slice(0, -3)) : e, t ? t => t.startsWith(e.name) && t.endsWith(e.ext) ? (al("it starts and ends with the right things"), + t.slice(e.name.length + 1, -1 * e.ext.length)) : o : t => t.startsWith(e.base) ? (al("it starts with the right things"), + t.slice(e.base.length + 1)) : o, r ? (e, t) => { + const n = e.split(i); + let o = n[n.length - 1]; + al("items: ", n, ", indexStr: ", o); + let s = e; + void 0 !== o && o.match(/^\d+$/) ? (s = e.slice(0, -1 * (o.length + 1)), al(`dateStr is ${s}`), + r && !s && (s = o, o = "0")) : o = "0"; + try { + const n = cl.parse(r, s, new Date(0, 0)); + return cl.asString(r, n) !== s ? e : (t.index = parseInt(o, 10), t.date = s, t.timestamp = n.getTime(), + ""); + } catch (t) { + return al(`Problem parsing ${s} as ${r}, error was: `, t), e; + } + } : (e, t) => e.match(/^\d+$/) ? (al("it has an index"), t.index = parseInt(e, 10), + "") : e ]; + return e => { + let t = { + filename: e, + index: 0, + isCompressed: !1 + }; + return s.reduce(((e, r) => r(e, t)), e) ? null : t; + }; +}, Fl = pl; + +var Sl = class extends yl { + constructor(e, t) { + if (hl(`constructor: creating RollingFileWriteStream. path=${e}`), "string" != typeof e || 0 === e.length) { + throw new Error(`Invalid filename: ${e}`); + } + if (e.endsWith(Dl.sep)) { + throw new Error(`Filename is a directory: ${e}`); + } + 0 === e.indexOf(`~${Dl.sep}`) && (e = e.replace("~", ml.homedir())), super(t), this.options = this._parseOption(t), + this.fileObject = Dl.parse(e), "" === this.fileObject.dir && (this.fileObject = Dl.parse(Dl.join(process.cwd(), e))), + this.fileFormatter = Cl({ + file: this.fileObject, + alwaysIncludeDate: this.options.alwaysIncludePattern, + needsIndex: this.options.maxSize < Number.MAX_SAFE_INTEGER, + compress: this.options.compress, + keepFileExt: this.options.keepFileExt, + fileNameSep: this.options.fileNameSep + }), this.fileNameParser = Al({ + file: this.fileObject, + keepFileExt: this.options.keepFileExt, + pattern: this.options.pattern, + fileNameSep: this.options.fileNameSep + }), this.state = { + currentSize: 0 + }, this.options.pattern && (this.state.currentDate = vl(this.options.pattern, gl())), + this.filename = this.fileFormatter({ + index: 0, + date: this.state.currentDate + }), [ "a", "a+", "as", "as+" ].includes(this.options.flags) && this._setExistingSizeAndDate(), + hl(`constructor: create new file ${this.filename}, state=${JSON.stringify(this.state)}`), + this._renewWriteStream(); + } + _setExistingSizeAndDate() { + try { + const e = El.statSync(this.filename); + this.state.currentSize = e.size, this.options.pattern && (this.state.currentDate = vl(this.options.pattern, e.mtime)); + } catch (e) { + return; + } + } + _parseOption(e) { + const t = { + maxSize: 0, + numToKeep: Number.MAX_SAFE_INTEGER, + encoding: "utf8", + mode: parseInt("0600", 8), + flags: "a", + compress: !1, + keepFileExt: !1, + alwaysIncludePattern: !1 + }, r = Object.assign({}, t, e); + if (r.maxSize) { + if (r.maxSize <= 0) { + throw new Error(`options.maxSize (${r.maxSize}) should be > 0`); + } + } else { + delete r.maxSize; + } + if (r.numBackups || 0 === r.numBackups) { + if (r.numBackups < 0) { + throw new Error(`options.numBackups (${r.numBackups}) should be >= 0`); + } + if (r.numBackups >= Number.MAX_SAFE_INTEGER) { + throw new Error(`options.numBackups (${r.numBackups}) should be < Number.MAX_SAFE_INTEGER`); + } + r.numToKeep = r.numBackups + 1; + } else if (r.numToKeep <= 0) { + throw new Error(`options.numToKeep (${r.numToKeep}) should be > 0`); + } + return hl(`_parseOption: creating stream with option=${JSON.stringify(r)}`), r; + } + _final(e) { + this.currentFileStream.end("", this.options.encoding, e); + } + _write(e, t, r) { + this._shouldRoll().then((() => { + hl(`_write: writing chunk. file=${this.currentFileStream.path} state=${JSON.stringify(this.state)} chunk=${e}`), + this.currentFileStream.write(e, t, (t => { + this.state.currentSize += e.length, r(t); + })); + })); + } + async _shouldRoll() { + (this._dateChanged() || this._tooBig()) && (hl(`_shouldRoll: rolling because dateChanged? ${this._dateChanged()} or tooBig? ${this._tooBig()}`), + await this._roll()); + } + _dateChanged() { + return this.state.currentDate && this.state.currentDate !== vl(this.options.pattern, gl()); + } + _tooBig() { + return this.state.currentSize >= this.options.maxSize; + } + _roll() { + return hl("_roll: closing the current stream"), new Promise(((e, t) => { + this.currentFileStream.end("", this.options.encoding, (() => { + this._moveOldFiles().then(e).catch(t); + })); + })); + } + async _moveOldFiles() { + const e = await this._getExistingFiles(); + for (let t = (this.state.currentDate ? e.filter((e => e.date === this.state.currentDate)) : e).length; t >= 0; t--) { + hl(`_moveOldFiles: i = ${t}`); + const e = this.fileFormatter({ + date: this.state.currentDate, + index: t + }), r = this.fileFormatter({ + date: this.state.currentDate, + index: t + 1 + }), n = { + compress: this.options.compress && 0 === t, + mode: this.options.mode + }; + await Fl(e, r, n); + } + this.state.currentSize = 0, this.state.currentDate = this.state.currentDate ? vl(this.options.pattern, gl()) : null, + hl(`_moveOldFiles: finished rolling files. state=${JSON.stringify(this.state)}`), + this._renewWriteStream(), await new Promise(((e, t) => { + this.currentFileStream.write("", "utf8", (() => { + this._clean().then(e).catch(t); + })); + })); + } + async _getExistingFiles() { + const e = await El.readdir(this.fileObject.dir).catch((() => [])); + hl(`_getExistingFiles: files=${e}`); + const t = e.map((e => this.fileNameParser(e))).filter((e => e)), r = e => (e.timestamp ? e.timestamp : gl().getTime()) - e.index; + return t.sort(((e, t) => r(e) - r(t))), t; + } + _renewWriteStream() { + const e = this.fileFormatter({ + date: this.state.currentDate, + index: 0 + }), t = e => { + try { + return El.mkdirSync(e, { + recursive: !0 + }); + } catch (r) { + if ("ENOENT" === r.code) { + return t(Dl.dirname(e)), t(e); + } + if ("EEXIST" !== r.code && "EROFS" !== r.code) { + throw r; + } + try { + if (El.statSync(e).isDirectory()) { + return e; + } + throw r; + } catch (e) { + throw r; + } + } + }; + t(this.fileObject.dir); + const r = { + flags: this.options.flags, + encoding: this.options.encoding, + mode: this.options.mode + }; + var n, i; + El.appendFileSync(e, "", (n = { + ...r + }, i = "flags", n["flag"] = n[i], delete n[i], n)), this.currentFileStream = El.createWriteStream(e, r), + this.currentFileStream.on("error", (e => { + this.emit("error", e); + })); + } + async _clean() { + const e = await this._getExistingFiles(); + if (hl(`_clean: numToKeep = ${this.options.numToKeep}, existingFiles = ${e.length}`), + hl("_clean: existing files are: ", e), this._tooManyFiles(e.length)) { + const r = e.slice(0, e.length - this.options.numToKeep).map((e => Dl.format({ + dir: this.fileObject.dir, + base: e.filename + }))); + await (t = r, hl(`deleteFiles: files to delete: ${t}`), Promise.all(t.map((e => El.unlink(e).catch((t => { + hl(`deleteFiles: error when unlinking ${e}, ignoring. Error was ${t}`); + })))))); + } + var t; + } + _tooManyFiles(e) { + return this.options.numToKeep > 0 && e > this.options.numToKeep; + } +}; + +const Ol = Sl; + +var wl = class extends Ol { + constructor(e, t, r, n) { + n || (n = {}), t && (n.maxSize = t), n.numBackups || 0 === n.numBackups || (r || 0 === r || (r = 1), + n.numBackups = r), super(e, n), this.backups = n.numBackups, this.size = this.options.maxSize; + } + get theStream() { + return this.currentFileStream; + } +}; + +const _l = Sl; + +var Il = { + RollingFileWriteStream: Sl, + RollingFileStream: wl, + DateRollingFileStream: class extends _l { + constructor(e, t, r) { + t && "object" == typeof t && (r = t, t = null), r || (r = {}), t || (t = "yyyy-MM-dd"), + r.pattern = t, r.numBackups || 0 === r.numBackups ? r.daysToKeep = r.numBackups : (r.daysToKeep || 0 === r.daysToKeep ? process.emitWarning("options.daysToKeep is deprecated due to the confusion it causes when used together with file size rolling. Please use options.numBackups instead.", "DeprecationWarning", "streamroller-DEP0001") : r.daysToKeep = 1, + r.numBackups = r.daysToKeep), super(e, r), this.mode = this.options.mode; + } + get theStream() { + return this.currentFileStream; + } + } +}; + +const bl = Io("log4js:file"), Rl = t, Pl = Il, Nl = n, Tl = Nl.EOL; + +let Ll = !1; + +const Ml = new Set; + +function Bl() { + Ml.forEach((e => { + e.sighupHandler(); + })); +} + +tu.configure = function(e, t) { + let r = t.basicLayout; + return e.layout && (r = t.layout(e.layout.type, e.layout)), e.mode = e.mode || 384, + function(e, t, r, n, i, o) { + if ("string" != typeof e || 0 === e.length) { + throw new Error(`Invalid filename: ${e}`); + } + if (e.endsWith(Rl.sep)) { + throw new Error(`Filename is a directory: ${e}`); + } + function s(e, t, r, n) { + const i = new Pl.RollingFileStream(e, t, r, n); + return i.on("error", (t => { + console.error("log4js.fileAppender - Writing to file %s, error happened ", e, t); + })), i.on("drain", (() => { + process.emit("log4js:pause", !1); + })), i; + } + e = e.replace(new RegExp(`^~(?=${Rl.sep}.+)`), Nl.homedir()), e = Rl.normalize(e), + bl("Creating file appender (", e, ", ", r, ", ", n = n || 0 === n ? n : 5, ", ", i, ", ", o, ")"); + let u = s(e, r, n, i); + const a = function(e) { + if (u.writable) { + if (!0 === i.removeColor) { + const t = /\x1b[[0-9;]*m/g; + e.data = e.data.map((e => "string" == typeof e ? e.replace(t, "") : e)); + } + u.write(t(e, o) + Tl, "utf8") || process.emit("log4js:pause", !0); + } + }; + return a.reopen = function() { + u.end((() => { + u = s(e, r, n, i); + })); + }, a.sighupHandler = function() { + bl("SIGHUP handler called."), a.reopen(); + }, a.shutdown = function(e) { + Ml.delete(a), 0 === Ml.size && Ll && (process.removeListener("SIGHUP", Bl), Ll = !1), + u.end("", "utf-8", e); + }, Ml.add(a), Ll || (process.on("SIGHUP", Bl), Ll = !0), a; + }(e.filename, r, e.maxLogSize, e.backups, e, e.timezoneOffset); +}; + +var xl = {}; + +const kl = Il, $l = n.EOL; + +function jl(e, t, r, n, i) { + n.maxSize = n.maxLogSize; + const o = function(e, t, r) { + const n = new kl.DateRollingFileStream(e, t, r); + return n.on("error", (t => { + console.error("log4js.dateFileAppender - Writing to file %s, error happened ", e, t); + })), n.on("drain", (() => { + process.emit("log4js:pause", !1); + })), n; + }(e, t, n), s = function(e) { + o.writable && (o.write(r(e, i) + $l, "utf8") || process.emit("log4js:pause", !0)); + }; + return s.shutdown = function(e) { + o.end("", "utf-8", e); + }, s; +} + +xl.configure = function(e, t) { + let r = t.basicLayout; + return e.layout && (r = t.layout(e.layout.type, e.layout)), e.alwaysIncludePattern || (e.alwaysIncludePattern = !1), + e.mode = e.mode || 384, jl(e.filename, e.pattern, r, e, e.timezoneOffset); +}; + +var Hl = {}; + +const Gl = Io("log4js:fileSync"), Ul = t, Vl = e, Jl = n, Wl = Jl.EOL; + +function zl(e, t) { + const r = e => { + try { + return Vl.mkdirSync(e, { + recursive: !0 + }); + } catch (t) { + if ("ENOENT" === t.code) { + return r(Ul.dirname(e)), r(e); + } + if ("EEXIST" !== t.code && "EROFS" !== t.code) { + throw t; + } + try { + if (Vl.statSync(e).isDirectory()) { + return e; + } + throw t; + } catch (e) { + throw t; + } + } + }; + r(Ul.dirname(e)), Vl.appendFileSync(e, "", { + mode: t.mode, + flag: t.flags + }); +} + +class Kl { + constructor(e, t, r, n) { + if (Gl("In RollingFileStream"), t < 0) { + throw new Error(`maxLogSize (${t}) should be > 0`); + } + this.filename = e, this.size = t, this.backups = r, this.options = n, this.currentSize = 0, + this.currentSize = function(e) { + let t = 0; + try { + t = Vl.statSync(e).size; + } catch (t) { + zl(e, n); + } + return t; + }(this.filename); + } + shouldRoll() { + return Gl("should roll with current size %d, and max size %d", this.currentSize, this.size), + this.currentSize >= this.size; + } + roll(e) { + const t = this, r = new RegExp(`^${Ul.basename(e)}`); + function n(e) { + return r.test(e); + } + function i(t) { + return parseInt(t.slice(`${Ul.basename(e)}.`.length), 10) || 0; + } + function o(e, t) { + return i(e) - i(t); + } + function s(r) { + const n = i(r); + if (Gl(`Index of ${r} is ${n}`), 0 === t.backups) { + Vl.truncateSync(e, 0); + } else if (n < t.backups) { + try { + Vl.unlinkSync(`${e}.${n + 1}`); + } catch (e) {} + Gl(`Renaming ${r} -> ${e}.${n + 1}`), Vl.renameSync(Ul.join(Ul.dirname(e), r), `${e}.${n + 1}`); + } + } + Gl("Rolling, rolling, rolling"), Gl("Renaming the old files"), Vl.readdirSync(Ul.dirname(e)).filter(n).sort(o).reverse().forEach(s); + } + write(e, t) { + const r = this; + Gl("in write"), this.shouldRoll() && (this.currentSize = 0, this.roll(this.filename)), + Gl("writing the chunk to the file"), r.currentSize += e.length, Vl.appendFileSync(r.filename, e); + } +} + +Hl.configure = function(e, t) { + let r = t.basicLayout; + e.layout && (r = t.layout(e.layout.type, e.layout)); + const n = { + flags: e.flags || "a", + encoding: e.encoding || "utf8", + mode: e.mode || 384 + }; + return function(e, t, r, n, i, o) { + if ("string" != typeof e || 0 === e.length) { + throw new Error(`Invalid filename: ${e}`); + } + if (e.endsWith(Ul.sep)) { + throw new Error(`Filename is a directory: ${e}`); + } + e = e.replace(new RegExp(`^~(?=${Ul.sep}.+)`), Jl.homedir()), e = Ul.normalize(e), + Gl("Creating fileSync appender (", e, ", ", r, ", ", n = n || 0 === n ? n : 5, ", ", i, ", ", o, ")"); + const s = function(e, t, r) { + let n; + var o; + return t ? n = new Kl(e, t, r, i) : (zl(o = e, i), n = { + write(e) { + Vl.appendFileSync(o, e); + } + }), n; + }(e, r, n); + return e => { + s.write(t(e, o) + Wl); + }; + }(e.filename, r, e.maxLogSize, e.backups, n, e.timezoneOffset); +}; + +var Xl = {}; + +const Yl = Io("log4js:tcp"), ql = d; + +Xl.configure = function(e, t) { + Yl(`configure with config = ${e}`); + let r = function(e) { + return e.serialise(); + }; + return e.layout && (r = t.layout(e.layout.type, e.layout)), function(e, t) { + let r = !1; + const n = []; + let i, o = 3, s = "__LOG4JS__"; + function u(e) { + Yl("Writing log event to socket"), r = i.write(`${t(e)}${s}`, "utf8"); + } + function a() { + let e; + for (Yl("emptying buffer"); e = n.shift(); ) { + u(e); + } + } + function c(e) { + r ? u(e) : (Yl("buffering log event because it cannot write at the moment"), n.push(e)); + } + return function t() { + Yl(`appender creating socket to ${e.host || "localhost"}:${e.port || 5e3}`), s = `${e.endMsg || "__LOG4JS__"}`, + i = ql.createConnection(e.port || 5e3, e.host || "localhost"), i.on("connect", (() => { + Yl("socket connected"), a(), r = !0; + })), i.on("drain", (() => { + Yl("drain event received, emptying buffer"), r = !0, a(); + })), i.on("timeout", i.end.bind(i)), i.on("error", (e => { + Yl("connection error", e), r = !1, a(); + })), i.on("close", t); + }(), c.shutdown = function(e) { + Yl("shutdown called"), n.length && o ? (Yl("buffer has items, waiting 100ms to empty"), + o -= 1, setTimeout((() => { + c.shutdown(e); + }), 100)) : (i.removeAllListeners("close"), i.end(e)); + }, c; + }(e, r); +}; + +const Zl = t, Ql = Io("log4js:appenders"), ef = ko, tf = Hs, rf = us, nf = ns, of = Gs, sf = new Map; + +sf.set("console", Ws), sf.set("stdout", Ks), sf.set("stderr", Xs), sf.set("logLevelFilter", Ys), +sf.set("categoryFilter", qs), sf.set("noLogFilter", Qs), sf.set("file", tu), sf.set("dateFile", xl), +sf.set("fileSync", Hl), sf.set("tcp", Xl); + +const uf = new Map, af = (e, t) => { + let r; + try { + const t = `${e}.cjs`; + r = require.resolve(t), Ql("Loading module from ", t); + } catch (t) { + r = e, Ql("Loading module from ", e); + } + try { + return require(r); + } catch (r) { + return void ef.throwExceptionIf(t, "MODULE_NOT_FOUND" !== r.code, `appender "${e}" could not be loaded (error was: ${r})`); + } +}, cf = new Set, lf = (e, t) => { + if (uf.has(e)) { + return uf.get(e); + } + if (!t.appenders[e]) { + return !1; + } + if (cf.has(e)) { + throw new Error(`Dependency loop detected for appender ${e}.`); + } + cf.add(e), Ql(`Creating appender ${e}`); + const r = ff(e, t); + return cf.delete(e), uf.set(e, r), r; +}, ff = (e, t) => { + const r = t.appenders[e], n = r.type.configure ? r.type : ((e, t) => sf.get(e) || af(`./${e}`, t) || af(e, t) || require.main && require.main.filename && af(Zl.join(Zl.dirname(require.main.filename), e), t) || af(Zl.join(process.cwd(), e), t))(r.type, t); + return ef.throwExceptionIf(t, ef.not(n), `appender "${e}" is not valid (type "${r.type}" could not be found)`), + n.appender && (process.emitWarning(`Appender ${r.type} exports an appender function.`, "DeprecationWarning", "log4js-node-DEP0001"), + Ql("[log4js-node-DEP0001]", `DEPRECATION: Appender ${r.type} exports an appender function.`)), + n.shutdown && (process.emitWarning(`Appender ${r.type} exports a shutdown function.`, "DeprecationWarning", "log4js-node-DEP0002"), + Ql("[log4js-node-DEP0002]", `DEPRECATION: Appender ${r.type} exports a shutdown function.`)), + Ql(`${e}: clustering.isMaster ? ${tf.isMaster()}`), Ql(`${e}: appenderModule is ${u.inspect(n)}`), + tf.onlyOnMaster((() => (Ql(`calling appenderModule.configure for ${e} / ${r.type}`), + n.configure(of.modifyConfig(r), nf, (e => lf(e, t)), rf))), (() => {})); +}, df = e => { + if (uf.clear(), cf.clear(), !e) { + return; + } + const t = []; + Object.values(e.categories).forEach((e => { + t.push(...e.appenders); + })), Object.keys(e.appenders).forEach((r => { + (t.includes(r) || "tcp-server" === e.appenders[r].type || "multiprocess" === e.appenders[r].type) && lf(r, e); + })); +}, pf = () => { + df(); +}; + +pf(), ef.addListener((e => { + ef.throwExceptionIf(e, ef.not(ef.anObject(e.appenders)), 'must have a property "appenders" of type object.'); + const t = Object.keys(e.appenders); + ef.throwExceptionIf(e, ef.not(t.length), "must define at least one appender."), + t.forEach((t => { + ef.throwExceptionIf(e, ef.not(e.appenders[t].type), `appender "${t}" is not valid (must be an object with property "type")`); + })); +})), ef.addListener(df), as.exports = uf, as.exports.init = pf; + +var hf = as.exports, Ef = { + exports: {} +}; + +!function(e) { + const t = Io("log4js:categories"), r = ko, n = us, i = hf, o = new Map; + function s(e, t, r) { + if (!1 === t.inherit) { + return; + } + const n = r.lastIndexOf("."); + if (n < 0) { + return; + } + const i = r.slice(0, n); + let o = e.categories[i]; + o || (o = { + inherit: !0, + appenders: [] + }), s(e, o, i), !e.categories[i] && o.appenders && o.appenders.length && o.level && (e.categories[i] = o), + t.appenders = t.appenders || [], t.level = t.level || o.level, o.appenders.forEach((e => { + t.appenders.includes(e) || t.appenders.push(e); + })), t.parent = o; + } + function u(e) { + if (!e.categories) { + return; + } + Object.keys(e.categories).forEach((t => { + const r = e.categories[t]; + s(e, r, t); + })); + } + r.addPreProcessingListener((e => u(e))), r.addListener((e => { + r.throwExceptionIf(e, r.not(r.anObject(e.categories)), 'must have a property "categories" of type object.'); + const t = Object.keys(e.categories); + r.throwExceptionIf(e, r.not(t.length), "must define at least one category."), t.forEach((t => { + const o = e.categories[t]; + r.throwExceptionIf(e, [ r.not(o.appenders), r.not(o.level) ], `category "${t}" is not valid (must be an object with properties "appenders" and "level")`), + r.throwExceptionIf(e, r.not(Array.isArray(o.appenders)), `category "${t}" is not valid (appenders must be an array of appender names)`), + r.throwExceptionIf(e, r.not(o.appenders.length), `category "${t}" is not valid (appenders must contain at least one appender name)`), + Object.prototype.hasOwnProperty.call(o, "enableCallStack") && r.throwExceptionIf(e, "boolean" != typeof o.enableCallStack, `category "${t}" is not valid (enableCallStack must be boolean type)`), + o.appenders.forEach((n => { + r.throwExceptionIf(e, r.not(i.get(n)), `category "${t}" is not valid (appender "${n}" is not defined)`); + })), r.throwExceptionIf(e, r.not(n.getLevel(o.level)), `category "${t}" is not valid (level "${o.level}" not recognised; valid levels are ${n.levels.join(", ")})`); + })), r.throwExceptionIf(e, r.not(e.categories.default), 'must define a "default" category.'); + })); + const a = e => { + if (o.clear(), !e) { + return; + } + Object.keys(e.categories).forEach((r => { + const s = e.categories[r], u = []; + s.appenders.forEach((e => { + u.push(i.get(e)), t(`Creating category ${r}`), o.set(r, { + appenders: u, + level: n.getLevel(s.level), + enableCallStack: s.enableCallStack || !1 + }); + })); + })); + }, c = () => { + a(); + }; + c(), r.addListener(a); + const l = e => { + if (t(`configForCategory: searching for config for ${e}`), o.has(e)) { + return t(`configForCategory: ${e} exists in config, returning it`), o.get(e); + } + let r; + return e.indexOf(".") > 0 ? (t(`configForCategory: ${e} has hierarchy, cloning from parents`), + r = { + ...l(e.slice(0, e.lastIndexOf("."))) + }) : (o.has("default") || a({ + categories: { + default: { + appenders: [ "out" ], + level: "OFF" + } + } + }), t("configForCategory: cloning default category"), r = { + ...o.get("default") + }), o.set(e, r), r; + }; + e.exports = o, e.exports = Object.assign(e.exports, { + appendersForCategory: e => l(e).appenders, + getLevelForCategory: e => l(e).level, + setLevelForCategory: (e, t) => { + l(e).level = t; + }, + getEnableCallStackForCategory: e => !0 === l(e).enableCallStack, + setEnableCallStackForCategory: (e, t) => { + l(e).enableCallStack = t; + }, + init: c + }); +}(Ef); + +var Df = Ef.exports; + +const mf = Io("log4js:logger"), gf = Is, vf = us, yf = Hs, Cf = Df, Af = ko, Ff = /at (?:(.+)\s+\()?(?:(.+?):(\d+)(?::(\d+))?|([^)]+))\)?/; + +function Sf(e, t = 4) { + try { + const r = e.stack.split("\n").slice(t); + if (!r.length) { + return null; + } + const n = Ff.exec(r[0]); + if (n && 6 === n.length) { + let e = "", t = "", i = ""; + return n[1] && "" !== n[1] && ([t, i] = n[1].replace(/[[\]]/g, "").split(" as "), + i = i || "", t.includes(".") && ([e, t] = t.split("."))), { + fileName: n[2], + lineNumber: parseInt(n[3], 10), + columnNumber: parseInt(n[4], 10), + callStack: r.join("\n"), + className: e, + functionName: t, + functionAlias: i, + callerName: n[1] || "" + }; + } + console.error("log4js.logger - defaultParseCallStack error"); + } catch (e) { + console.error("log4js.logger - defaultParseCallStack error", e); + } + return null; +} + +let Of = class { + constructor(e) { + if (!e) { + throw new Error("No category provided."); + } + this.category = e, this.context = {}, this.callStackSkipIndex = 0, this.parseCallStack = Sf, + mf(`Logger created (${this.category}, ${this.level})`); + } + get level() { + return vf.getLevel(Cf.getLevelForCategory(this.category), vf.OFF); + } + set level(e) { + Cf.setLevelForCategory(this.category, vf.getLevel(e, this.level)); + } + get useCallStack() { + return Cf.getEnableCallStackForCategory(this.category); + } + set useCallStack(e) { + Cf.setEnableCallStackForCategory(this.category, !0 === e); + } + get callStackLinesToSkip() { + return this.callStackSkipIndex; + } + set callStackLinesToSkip(e) { + if ("number" != typeof e) { + throw new TypeError("Must be a number"); + } + if (e < 0) { + throw new RangeError("Must be >= 0"); + } + this.callStackSkipIndex = e; + } + log(e, ...t) { + const r = vf.getLevel(e); + r ? this.isLevelEnabled(r) && this._log(r, t) : Af.validIdentifier(e) && t.length > 0 ? (this.log(vf.WARN, "log4js:logger.log: valid log-level not found as first parameter given:", e), + this.log(vf.INFO, `[${e}]`, ...t)) : this.log(vf.INFO, e, ...t); + } + isLevelEnabled(e) { + return this.level.isLessThanOrEqualTo(e); + } + _log(e, t) { + mf(`sending log data (${e}) to appenders`); + const r = t.find((e => e instanceof Error)); + let n; + if (this.useCallStack) { + try { + r && (n = this.parseCallStack(r, this.callStackSkipIndex + 1)); + } catch (e) {} + n = n || this.parseCallStack(new Error, this.callStackSkipIndex + 3 + 1); + } + const i = new gf(this.category, e, t, this.context, n, r); + yf.send(i); + } + addContext(e, t) { + this.context[e] = t; + } + removeContext(e) { + delete this.context[e]; + } + clearContext() { + this.context = {}; + } + setParseCallStackFunction(e) { + if ("function" == typeof e) { + this.parseCallStack = e; + } else { + if (void 0 !== e) { + throw new TypeError("Invalid type passed to setParseCallStackFunction"); + } + this.parseCallStack = Sf; + } + } +}; + +function wf(e) { + const t = vf.getLevel(e), r = t.toString().toLowerCase().replace(/_([a-z])/g, (e => e[1].toUpperCase())), n = r[0].toUpperCase() + r.slice(1); + Of.prototype[`is${n}Enabled`] = function() { + return this.isLevelEnabled(t); + }, Of.prototype[r] = function(...e) { + this.log(t, ...e); + }; +} + +vf.levels.forEach(wf), Af.addListener((() => { + vf.levels.forEach(wf); +})); + +var _f = Of; + +const If = us; + +function bf(e) { + return e.originalUrl || e.url; +} + +function Rf(e, t) { + for (let r = 0; r < t.length; r++) { + e = e.replace(t[r].token, t[r].replacement); + } + return e; +} + +const Pf = Io("log4js:recording"), Nf = []; + +function Tf() { + return Nf.slice(); +} + +function Lf() { + Nf.length = 0; +} + +var Mf = { + configure: function() { + return function(e) { + Pf(`received logEvent, number of events now ${Nf.length + 1}`), Pf("log event was ", e), + Nf.push(e); + }; + }, + replay: Tf, + playback: Tf, + reset: Lf, + erase: Lf +}; + +const Bf = Io("log4js:main"), xf = e, kf = bo({ + proto: !0 +}), $f = ko, jf = hf, Hf = Df, Gf = _f, Uf = Hs, Vf = Mf; + +let Jf = !1; + +function Wf(e) { + if (!Jf) { + return; + } + Bf("Received log event ", e); + Hf.appendersForCategory(e.categoryName).forEach((t => { + t(e); + })); +} + +function zf(e) { + Jf && Kf(); + let t = e; + return "string" == typeof t && (t = function(e) { + Bf(`Loading configuration from ${e}`); + try { + return JSON.parse(xf.readFileSync(e, "utf8")); + } catch (t) { + throw new Error(`Problem reading config from file "${e}". Error was ${t.message}`, t); + } + }(e)), Bf(`Configuration is ${t}`), $f.configure(kf(t)), Uf.onMessage(Wf), Jf = !0, + Xf; +} + +function Kf(e = () => {}) { + if ("function" != typeof e) { + throw new TypeError("Invalid callback passed to shutdown"); + } + Bf("Shutdown called. Disabling all log writing."), Jf = !1; + const t = Array.from(jf.values()); + jf.init(), Hf.init(); + const r = t.reduce(((e, t) => t.shutdown ? e + 1 : e), 0); + 0 === r && (Bf("No appenders with shutdown functions found."), e()); + let n, i = 0; + function o(t) { + n = n || t, i += 1, Bf(`Appender shutdowns complete: ${i} / ${r}`), i >= r && (Bf("All shutdown functions completed."), + e(n)); + } + Bf(`Found ${r} appenders with shutdown functions.`), t.filter((e => e.shutdown)).forEach((e => e.shutdown(o))); +} + +const Xf = { + getLogger: function(e) { + return Jf || zf(process.env.LOG4JS_CONFIG || { + appenders: { + out: { + type: "stdout" + } + }, + categories: { + default: { + appenders: [ "out" ], + level: "OFF" + } + } + }), new Gf(e || "default"); + }, + configure: zf, + shutdown: Kf, + connectLogger: function(e, t) { + t = "string" == typeof t || "function" == typeof t ? { + format: t + } : t || {}; + const r = e; + let n = If.getLevel(t.level, If.INFO); + const i = t.format || ':remote-addr - - ":method :url HTTP/:http-version" :status :content-length ":referrer" ":user-agent"'; + return (e, o, s) => { + if (void 0 !== e._logging) { + return s(); + } + if ("function" != typeof t.nolog) { + const r = function(e) { + let t = null; + if (e instanceof RegExp && (t = e), "string" == typeof e && (t = new RegExp(e)), + Array.isArray(e)) { + const r = e.map((e => e.source ? e.source : e)); + t = new RegExp(r.join("|")); + } + return t; + }(t.nolog); + if (r && r.test(e.originalUrl)) { + return s(); + } + } + if (r.isLevelEnabled(n) || "auto" === t.level) { + const s = new Date, {writeHead: u} = o; + e._logging = !0, o.writeHead = (e, t) => { + o.writeHead = u, o.writeHead(e, t), o.__statusCode = e, o.__headers = t || {}; + }; + let a = !1; + const c = () => { + if (a) { + return; + } + if (a = !0, "function" == typeof t.nolog && !0 === t.nolog(e, o)) { + return void (e._logging = !1); + } + o.responseTime = new Date - s, o.statusCode && "auto" === t.level && (n = If.INFO, + o.statusCode >= 300 && (n = If.WARN), o.statusCode >= 400 && (n = If.ERROR)), n = function(e, t, r) { + let n = t; + if (r) { + const t = r.find((t => { + let r = !1; + return r = t.from && t.to ? e >= t.from && e <= t.to : -1 !== t.codes.indexOf(e), + r; + })); + t && (n = If.getLevel(t.level, n)); + } + return n; + }(o.statusCode, n, t.statusRules); + const u = function(e, t, r) { + const n = []; + return n.push({ + token: ":url", + replacement: bf(e) + }), n.push({ + token: ":protocol", + replacement: e.protocol + }), n.push({ + token: ":hostname", + replacement: e.hostname + }), n.push({ + token: ":method", + replacement: e.method + }), n.push({ + token: ":status", + replacement: t.__statusCode || t.statusCode + }), n.push({ + token: ":response-time", + replacement: t.responseTime + }), n.push({ + token: ":date", + replacement: (new Date).toUTCString() + }), n.push({ + token: ":referrer", + replacement: e.headers.referer || e.headers.referrer || "" + }), n.push({ + token: ":http-version", + replacement: `${e.httpVersionMajor}.${e.httpVersionMinor}` + }), n.push({ + token: ":remote-addr", + replacement: e.headers["x-forwarded-for"] || e.ip || e._remoteAddress || e.socket && (e.socket.remoteAddress || e.socket.socket && e.socket.socket.remoteAddress) + }), n.push({ + token: ":user-agent", + replacement: e.headers["user-agent"] + }), n.push({ + token: ":content-length", + replacement: t.getHeader("content-length") || t.__headers && t.__headers["Content-Length"] || "-" + }), n.push({ + token: /:req\[([^\]]+)]/g, + replacement: (t, r) => e.headers[r.toLowerCase()] + }), n.push({ + token: /:res\[([^\]]+)]/g, + replacement: (e, r) => t.getHeader(r.toLowerCase()) || t.__headers && t.__headers[r] + }), (e => { + const t = e.concat(); + for (let e = 0; e < t.length; ++e) { + for (let r = e + 1; r < t.length; ++r) { + t[e].token == t[r].token && t.splice(r--, 1); + } + } + return t; + })(r.concat(n)); + }(e, o, t.tokens || []); + if (t.context && r.addContext("res", o), "function" == typeof i) { + const t = i(e, o, (e => Rf(e, u))); + t && r.log(n, t); + } else { + r.log(n, Rf(i, u)); + } + t.context && r.removeContext("res"); + }; + o.on("end", c), o.on("finish", c), o.on("error", c), o.on("close", c); + } + return s(); + }; + }, + levels: us, + addLayout: ns.addLayout, + recording: function() { + return Vf; + } +}; + +var Yf = Xf; + +!function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.coreParameter = e.defaultProperties = e.defaultStartParam = e.LogLevelMap = e.AnalyzeModeKeyMap = e.OldAnalyzeModeMap = e.AnalyzeModeMap = e.AnalyzeMode = e.CoreParameter = void 0; + const t = Yf; + class r { + constructor() { + this._properties = {}, this._extParams = {}, this._startParams = { + ...e.defaultStartParam + }, this._workspaceDir = ""; + } + get properties() { + return this._properties; + } + set properties(e) { + this._properties = e; + } + get extParams() { + return this._extParams; + } + set extParams(e) { + this._extParams = e; + } + get startParams() { + return this._startParams; + } + get workspaceDir() { + return this._workspaceDir; + } + set workspaceDir(e) { + this._workspaceDir = e; + } + clean() { + this._properties = {}, this._extParams = {}, this._startParams = { + ...e.defaultStartParam + }, this._workspaceDir = ""; + } + } + var n, i; + e.CoreParameter = r, (i = n = e.AnalyzeMode || (e.AnalyzeMode = {}))[i.NORMAL = 0] = "NORMAL", + i[i.ADVANCED = 1] = "ADVANCED", i[i.FALSE = 2] = "FALSE", e.AnalyzeModeMap = new Map([ [ "default", n.NORMAL ], [ "verbose", n.ADVANCED ], [ !1, n.FALSE ], [ "false", n.FALSE ], [ "normal", n.NORMAL ], [ "advanced", n.ADVANCED ] ]), + e.OldAnalyzeModeMap = new Map([ [ "default", "normal" ], [ "verbose", "advanced" ] ]), + e.AnalyzeModeKeyMap = new Map([ [ n.NORMAL, "normal" ], [ n.ADVANCED, "advanced" ], [ n.FALSE, !1 ] ]), + e.LogLevelMap = new Map([ [ "info", t.levels.INFO ], [ 'debug"', t.levels.DEBUG ], [ 'warn"', t.levels.WARN ], [ 'error"', t.levels.ERROR ] ]), + e.defaultStartParam = { + hvigorfileTypeCheck: !1, + parallelExecution: !0, + incrementalExecution: !0, + printStackTrace: !1, + daemon: !0, + analyze: n.NORMAL, + logLevel: t.levels.INFO + }, e.defaultProperties = { + enableSignTask: !0, + skipNativeIncremental: !1 + }, e.coreParameter = new r; +}(Do); + +var qf = {}, Zf = {}, Qf = {}; + +!function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.Unicode = void 0; + class t {} + e.Unicode = t, t.SPACE_SEPARATOR = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/, t.ID_START = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE83\uDE86-\uDE89\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]/, + t.ID_CONTINUE = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF9\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDE00-\uDE3E\uDE47\uDE50-\uDE83\uDE86-\uDE99\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/; +}(Qf), function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.JudgeUtil = void 0; + const t = Qf; + e.JudgeUtil = class { + static isIgnoreChar(e) { + return "string" == typeof e && ("\t" === e || "\v" === e || "\f" === e || " " === e || " " === e || "\ufeff" === e || "\n" === e || "\r" === e || "\u2028" === e || "\u2029" === e); + } + static isSpaceSeparator(e) { + return "string" == typeof e && t.Unicode.SPACE_SEPARATOR.test(e); + } + static isIdStartChar(e) { + return "string" == typeof e && (e >= "a" && e <= "z" || e >= "A" && e <= "Z" || "$" === e || "_" === e || t.Unicode.ID_START.test(e)); + } + static isIdContinueChar(e) { + return "string" == typeof e && (e >= "a" && e <= "z" || e >= "A" && e <= "Z" || e >= "0" && e <= "9" || "$" === e || "_" === e || "‌" === e || "‍" === e || t.Unicode.ID_CONTINUE.test(e)); + } + static isDigitWithoutZero(e) { + return /[1-9]/.test(e); + } + static isDigit(e) { + return "string" == typeof e && /[0-9]/.test(e); + } + static isHexDigit(e) { + return "string" == typeof e && /[0-9A-Fa-f]/.test(e); + } + }; +}(Zf), function(r) { + var i = E && E.__importDefault || function(e) { + return e && e.__esModule ? e : { + default: e + }; + }; + Object.defineProperty(r, "__esModule", { + value: !0 + }), r.parseJsonText = r.parseJsonFile = void 0; + const o = i(e), s = i(n), u = i(t), a = Zf; + var c, l; + (l = c || (c = {}))[l.Char = 0] = "Char", l[l.EOF = 1] = "EOF", l[l.Identifier = 2] = "Identifier"; + let f, d, p, h, D, m, g = "start", v = [], y = 0, C = 1, A = 0, F = !1, S = "default", O = "'", w = 1; + function _(e, t = !1) { + d = String(e), g = "start", v = [], y = 0, C = 1, A = 0, h = void 0, F = t; + do { + f = I(), M[g](); + } while ("eof" !== f.type); + return h; + } + function I() { + for (S = "default", D = "", O = "'", w = 1; ;) { + m = b(); + const e = P[S](); + if (e) { + return e; + } + } + } + function b() { + if (d[y]) { + return String.fromCodePoint(d.codePointAt(y)); + } + } + function R() { + const e = b(); + return "\n" === e ? (C++, A = 0) : e ? A += e.length : A++, e && (y += e.length), + e; + } + r.parseJsonFile = function(e, t = !1, r = "utf-8") { + const n = o.default.readFileSync(u.default.resolve(e), { + encoding: r + }); + try { + return _(n, t); + } catch (t) { + if (t instanceof SyntaxError) { + const r = t.message.split("at"); + if (2 === r.length) { + throw new Error(`${r[0].trim()}${s.default.EOL}\t at ${e}:${r[1].trim()}`); + } + } + throw new Error(`${e} is not in valid JSON/JSON5 format.`); + } + }, r.parseJsonText = _; + const P = { + default() { + switch (m) { + case "/": + return R(), void (S = "comment"); + + case void 0: + return R(), N("eof"); + } + if (!a.JudgeUtil.isIgnoreChar(m) && !a.JudgeUtil.isSpaceSeparator(m)) { + return P[g](); + } + R(); + }, + start() { + S = "value"; + }, + beforePropertyName() { + switch (m) { + case "$": + case "_": + return D = R(), void (S = "identifierName"); + + case "\\": + return R(), void (S = "identifierNameStartEscape"); + + case "}": + return N("punctuator", R()); + + case '"': + case "'": + return O = m, R(), void (S = "string"); + } + if (a.JudgeUtil.isIdStartChar(m)) { + return D += R(), void (S = "identifierName"); + } + throw $(c.Char, R()); + }, + afterPropertyName() { + if (":" === m) { + return N("punctuator", R()); + } + throw $(c.Char, R()); + }, + beforePropertyValue() { + S = "value"; + }, + afterPropertyValue() { + switch (m) { + case ",": + case "}": + return N("punctuator", R()); + } + throw $(c.Char, R()); + }, + beforeArrayValue() { + if ("]" === m) { + return N("punctuator", R()); + } + S = "value"; + }, + afterArrayValue() { + switch (m) { + case ",": + case "]": + return N("punctuator", R()); + } + throw $(c.Char, R()); + }, + end() { + throw $(c.Char, R()); + }, + comment() { + switch (m) { + case "*": + return R(), void (S = "multiLineComment"); + + case "/": + return R(), void (S = "singleLineComment"); + } + throw $(c.Char, R()); + }, + multiLineComment() { + switch (m) { + case "*": + return R(), void (S = "multiLineCommentAsterisk"); + + case void 0: + throw $(c.Char, R()); + } + R(); + }, + multiLineCommentAsterisk() { + switch (m) { + case "*": + return void R(); + + case "/": + return R(), void (S = "default"); + + case void 0: + throw $(c.Char, R()); + } + R(), S = "multiLineComment"; + }, + singleLineComment() { + switch (m) { + case "\n": + case "\r": + case "\u2028": + case "\u2029": + return R(), void (S = "default"); + + case void 0: + return R(), N("eof"); + } + R(); + }, + value() { + switch (m) { + case "{": + case "[": + return N("punctuator", R()); + + case "n": + return R(), T("ull"), N("null", null); + + case "t": + return R(), T("rue"), N("boolean", !0); + + case "f": + return R(), T("alse"), N("boolean", !1); + + case "-": + case "+": + return "-" === R() && (w = -1), void (S = "numerical"); + + case ".": + case "0": + case "I": + case "N": + return void (S = "numerical"); + + case '"': + case "'": + return O = m, R(), D = "", void (S = "string"); + } + if (void 0 === m || !a.JudgeUtil.isDigitWithoutZero(m)) { + throw $(c.Char, R()); + } + S = "numerical"; + }, + numerical() { + switch (m) { + case ".": + return D = R(), void (S = "decimalPointLeading"); + + case "0": + return D = R(), void (S = "zero"); + + case "I": + return R(), T("nfinity"), N("numeric", w * (1 / 0)); + + case "N": + return R(), T("aN"), N("numeric", NaN); + } + if (void 0 !== m && a.JudgeUtil.isDigitWithoutZero(m)) { + return D = R(), void (S = "decimalInteger"); + } + throw $(c.Char, R()); + }, + zero() { + switch (m) { + case ".": + case "e": + case "E": + return void (S = "decimal"); + + case "x": + case "X": + return D += R(), void (S = "hexadecimal"); + } + return N("numeric", 0); + }, + decimalInteger() { + switch (m) { + case ".": + case "e": + case "E": + return void (S = "decimal"); + } + if (!a.JudgeUtil.isDigit(m)) { + return N("numeric", w * Number(D)); + } + D += R(); + }, + decimal() { + switch (m) { + case ".": + D += R(), S = "decimalFraction"; + break; + + case "e": + case "E": + D += R(), S = "decimalExponent"; + } + }, + decimalPointLeading() { + if (a.JudgeUtil.isDigit(m)) { + return D += R(), void (S = "decimalFraction"); + } + throw $(c.Char, R()); + }, + decimalFraction() { + switch (m) { + case "e": + case "E": + return D += R(), void (S = "decimalExponent"); + } + if (!a.JudgeUtil.isDigit(m)) { + return N("numeric", w * Number(D)); + } + D += R(); + }, + decimalExponent() { + switch (m) { + case "+": + case "-": + return D += R(), void (S = "decimalExponentSign"); + } + if (a.JudgeUtil.isDigit(m)) { + return D += R(), void (S = "decimalExponentInteger"); + } + throw $(c.Char, R()); + }, + decimalExponentSign() { + if (a.JudgeUtil.isDigit(m)) { + return D += R(), void (S = "decimalExponentInteger"); + } + throw $(c.Char, R()); + }, + decimalExponentInteger() { + if (!a.JudgeUtil.isDigit(m)) { + return N("numeric", w * Number(D)); + } + D += R(); + }, + hexadecimal() { + if (a.JudgeUtil.isHexDigit(m)) { + return D += R(), void (S = "hexadecimalInteger"); + } + throw $(c.Char, R()); + }, + hexadecimalInteger() { + if (!a.JudgeUtil.isHexDigit(m)) { + return N("numeric", w * Number(D)); + } + D += R(); + }, + identifierNameStartEscape() { + if ("u" !== m) { + throw $(c.Char, R()); + } + R(); + const e = L(); + switch (e) { + case "$": + case "_": + break; + + default: + if (!a.JudgeUtil.isIdStartChar(e)) { + throw $(c.Identifier); + } + } + D += e, S = "identifierName"; + }, + identifierName() { + switch (m) { + case "$": + case "_": + case "‌": + case "‍": + return void (D += R()); + + case "\\": + return R(), void (S = "identifierNameEscape"); + } + if (!a.JudgeUtil.isIdContinueChar(m)) { + return N("identifier", D); + } + D += R(); + }, + identifierNameEscape() { + if ("u" !== m) { + throw $(c.Char, R()); + } + R(); + const e = L(); + switch (e) { + case "$": + case "_": + case "‌": + case "‍": + break; + + default: + if (!a.JudgeUtil.isIdContinueChar(e)) { + throw $(c.Identifier); + } + } + D += e, S = "identifierName"; + }, + string() { + switch (m) { + case "\\": + return R(), void (D += function() { + const e = b(), t = function() { + switch (b()) { + case "b": + return R(), "\b"; + + case "f": + return R(), "\f"; + + case "n": + return R(), "\n"; + + case "r": + return R(), "\r"; + + case "t": + return R(), "\t"; + + case "v": + return R(), "\v"; + } + }(); + if (t) { + return t; + } + switch (e) { + case "0": + if (R(), a.JudgeUtil.isDigit(b())) { + throw $(c.Char, R()); + } + return "\0"; + + case "x": + return R(), function() { + let e = "", t = b(); + if (!a.JudgeUtil.isHexDigit(t)) { + throw $(c.Char, R()); + } + if (e += R(), t = b(), !a.JudgeUtil.isHexDigit(t)) { + throw $(c.Char, R()); + } + return e += R(), String.fromCodePoint(parseInt(e, 16)); + }(); + + case "u": + return R(), L(); + + case "\n": + case "\u2028": + case "\u2029": + return R(), ""; + + case "\r": + return R(), "\n" === b() && R(), ""; + } + if (void 0 === e || a.JudgeUtil.isDigitWithoutZero(e)) { + throw $(c.Char, R()); + } + return R(); + }()); + + case '"': + case "'": + if (m === O) { + const e = N("string", D); + return R(), e; + } + return void (D += R()); + + case "\n": + case "\r": + case void 0: + throw $(c.Char, R()); + + case "\u2028": + case "\u2029": + !function(e) { + console.warn(`JSON5: '${k(e)}' in strings is not valid ECMAScript; consider escaping.`); + }(m); + } + D += R(); + } + }; + function N(e, t) { + return { + type: e, + value: t, + line: C, + column: A + }; + } + function T(e) { + for (const t of e) { + if (b() !== t) { + throw $(c.Char, R()); + } + R(); + } + } + function L() { + let e = "", t = 4; + for (;t-- > 0; ) { + const t = b(); + if (!a.JudgeUtil.isHexDigit(t)) { + throw $(c.Char, R()); + } + e += R(); + } + return String.fromCodePoint(parseInt(e, 16)); + } + const M = { + start() { + if ("eof" === f.type) { + throw $(c.EOF); + } + B(); + }, + beforePropertyName() { + switch (f.type) { + case "identifier": + case "string": + return p = f.value, void (g = "afterPropertyName"); + + case "punctuator": + return void x(); + + case "eof": + throw $(c.EOF); + } + }, + afterPropertyName() { + if ("eof" === f.type) { + throw $(c.EOF); + } + g = "beforePropertyValue"; + }, + beforePropertyValue() { + if ("eof" === f.type) { + throw $(c.EOF); + } + B(); + }, + afterPropertyValue() { + if ("eof" === f.type) { + throw $(c.EOF); + } + switch (f.value) { + case ",": + return void (g = "beforePropertyName"); + + case "}": + x(); + } + }, + beforeArrayValue() { + if ("eof" === f.type) { + throw $(c.EOF); + } + "punctuator" !== f.type || "]" !== f.value ? B() : x(); + }, + afterArrayValue() { + if ("eof" === f.type) { + throw $(c.EOF); + } + switch (f.value) { + case ",": + return void (g = "beforeArrayValue"); + + case "]": + x(); + } + }, + end() {} + }; + function B() { + const e = function() { + let e; + switch (f.type) { + case "punctuator": + switch (f.value) { + case "{": + e = {}; + break; + + case "[": + e = []; + } + break; + + case "null": + case "boolean": + case "numeric": + case "string": + e = f.value; + } + return e; + }(); + if (F && "object" == typeof e && (e._line = C, e._column = A), void 0 === h) { + h = e; + } else { + const t = v[v.length - 1]; + Array.isArray(t) ? F && "object" != typeof e ? t.push({ + value: e, + _line: C, + _column: A + }) : t.push(e) : t[p] = F && "object" != typeof e ? { + value: e, + _line: C, + _column: A + } : e; + } + !function(e) { + if (e && "object" == typeof e) { + v.push(e), g = Array.isArray(e) ? "beforeArrayValue" : "beforePropertyName"; + } else { + const e = v[v.length - 1]; + g = e ? Array.isArray(e) ? "afterArrayValue" : "afterPropertyValue" : "end"; + } + }(e); + } + function x() { + v.pop(); + const e = v[v.length - 1]; + g = e ? Array.isArray(e) ? "afterArrayValue" : "afterPropertyValue" : "end"; + } + function k(e) { + const t = { + "'": "\\'", + '"': '\\"', + "\\": "\\\\", + "\b": "\\b", + "\f": "\\f", + "\n": "\\n", + "\r": "\\r", + "\t": "\\t", + "\v": "\\v", + "\0": "\\0", + "\u2028": "\\u2028", + "\u2029": "\\u2029" + }; + if (t[e]) { + return t[e]; + } + if (e < " ") { + const t = e.charCodeAt(0).toString(16); + return `\\x${`00${t}`.substring(t.length)}`; + } + return e; + } + function $(e, t) { + let r = ""; + switch (e) { + case c.Char: + r = void 0 === t ? `JSON5: invalid end of input at ${C}:${A}` : `JSON5: invalid character '${k(t)}' at ${C}:${A}`; + break; + + case c.EOF: + r = `JSON5: invalid end of input at ${C}:${A}`; + break; + + case c.Identifier: + A -= 5, r = `JSON5: invalid identifier character at ${C}:${A}`; + } + const n = new j(r); + return n.lineNumber = C, n.columnNumber = A, n; + } + class j extends SyntaxError {} +}(qf), function(n) { + var i = E && E.__importDefault || function(e) { + return e && e.__esModule ? e : { + default: e + }; + }; + Object.defineProperty(n, "__esModule", { + value: !0 + }), n.HvigorConfigLoader = void 0; + const o = i(e), s = i(t), u = i(r), a = Do, c = qt, l = Zt, f = Zt, d = qf; + class p { + constructor() { + const e = s.default.resolve(l.HVIGOR_PROJECT_WRAPPER_HOME, c.DEFAULT_HVIGOR_CONFIG_JSON_FILE_NAME); + if (!o.default.existsSync(e)) { + return; + } + const t = (0, d.parseJsonFile)(e), r = s.default.resolve(f.HVIGOR_USER_HOME, c.DEFAULT_HVIGOR_CONFIG_JSON_FILE_NAME); + let n; + o.default.existsSync(r) && (n = (0, d.parseJsonFile)(r), t.properties = { + ...n.properties, + ...t.properties + }), this.hvigorConfig = t; + } + static init(e) { + var t, r; + if (void 0 === e) { + return void (u.default.env.config = void 0); + } + const n = p.getConfigs(); + let i = {}; + null === (t = e.config) || void 0 === t || t.forEach((e => { + const t = e.split("="); + 2 === t.length && (i[t[0]] = t[t.length - 1], this.initCommandLineProperties(t[0], t[t.length - 1])); + })), Array.isArray(e.prop) && (null === (r = e.prop) || void 0 === r || r.forEach((e => { + const t = e.split("="); + 2 === t.length && (i[t[0]] = t[t.length - 1], this.initCommandLineProperties(t[0], t[t.length - 1])); + }))), i = { + ...n, + ...i + }, u.default.env.config = JSON.stringify(i); + } + static initCommandLineProperties(e, t) { + if (!e.startsWith(`${c.PROPERTIES + c.DOT}`)) { + return; + } + const r = e.substring(`${c.PROPERTIES + c.DOT}`.length); + a.coreParameter.properties[r] = this.convertToParamValue(t); + } + static convertToParamValue(e) { + let t = Number(e); + return e.length <= 16 && !isNaN(t) ? t : (t = "true" === e || "false" !== e && t, + "boolean" == typeof t ? t : e.trim()); + } + getHvigorConfig() { + return this.hvigorConfig; + } + getPropertiesConfigValue(e) { + var t; + const r = p.getConfigs()["properties.".concat(e)], n = void 0 !== u.default.env.config && null !== (t = JSON.parse(u.default.env.config)["properties.".concat(e)]) && void 0 !== t ? t : r; + return void 0 !== n ? this.parseConfigValue(n) : void 0 !== this.hvigorConfig && this.hvigorConfig.properties ? this.hvigorConfig.properties[e] : void 0; + } + static getInstance() { + return new p; + } + static getConfigs() { + const e = u.default.argv.slice(2), t = /^(--config|-c).*/, r = /^(--config|-c)$/, n = {}; + for (const [i, o] of e.entries()) { + if (r.test(o)) { + const t = e[i + 1].split("="); + 2 === t.length && (n[t[0]] = t[t.length - 1]); + } else if (t.test(o)) { + const e = o.match(t); + if (e && e[0].length < o.length) { + const t = o.substring(e[0].length).split("="); + 2 === t.length && (n[t[0]] = t[t.length - 1]); + } + } + } + return n; + } + parseConfigValue(e) { + if ("true" === e.toLowerCase()) { + return !0; + } + if ("false" === e.toLowerCase()) { + return !1; + } + const t = Number(e); + return isNaN(t) ? e : t; + } + } + n.HvigorConfigLoader = p; +}(Eo); + +var ed = {}, td = {}, rd = {}, nd = {}; + +!function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.BaseEvent = e.EventBody = e.EventHead = e.MetricEventType = void 0, function(e) { + e.DURATION = "duration", e.INSTANT = "instant", e.COUNTER = "counter", e.GAUGE = "gauge", + e.OBJECT = "object", e.METADATA = "metadata", e.MARK = "mark", e.LOG = "log", e.CONTINUAL = "continual"; + }(e.MetricEventType || (e.MetricEventType = {})); + e.EventHead = class { + constructor(e, t, r, n) { + this.id = e, this.name = t, this.description = r, this.type = n; + } + }; + e.EventBody = class { + constructor(e, t) { + this.pid = e, this.tid = t, this.startTime = Number(process.hrtime.bigint()); + } + }; + e.BaseEvent = class { + constructor(e, t) { + this.head = e, this.body = t, this.additional = {}; + } + setStartTime(e) { + this.body.startTime = null != e ? e : Number(process.hrtime.bigint()); + } + setEndTime(e) { + this.body.endTime = null != e ? e : Number(process.hrtime.bigint()); + } + setTotalTime(e) { + this.body.totalTime = e; + } + getId() { + return this.head.id; + } + getName() { + return this.head.name; + } + getDescription() { + return this.head.description; + } + setName(e) { + this.head.name = e; + } + getType() { + return this.head.type; + } + setType(e) { + this.head.type = e; + } + getTid() { + return this.body.tid; + } + setTid(e) { + return this.body.tid = e, this; + } + }; +}(nd), function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.LogEvent = e.LogEventAdditional = e.MetricLogType = void 0; + const t = nd; + !function(e) { + e.DEBUG = "debug", e.INFO = "info", e.WARN = "warn", e.ERROR = "error", e.DETAIL = "detail"; + }(e.MetricLogType || (e.MetricLogType = {})); + class r { + constructor(e) { + this.logType = e, this.children = []; + } + } + e.LogEventAdditional = r; + class n extends t.BaseEvent { + constructor(e, n, i, o, s, u) { + super(new t.EventHead(e, n, i, t.MetricEventType.LOG), new t.EventBody(o, s)), this.additional = new r(u); + } + getLogType() { + return this.additional.logType; + } + setLogType(e) { + this.additional.logType = e; + } + getDurationId() { + return this.additional.durationId; + } + setDurationId(e) { + this.additional.durationId = e; + } + getContinualId() { + return this.additional.continualId; + } + setContinualId(e) { + this.additional.continualId = e; + } + addChild(e) { + e && -1 === this.additional.children.indexOf(e) && this.additional.children.push(e); + } + setParent(e) { + this.additional.parent || (this.additional.parent = e); + } + } + e.LogEvent = n; +}(rd); + +var id = {}, od = {}, sd = {}, ud = {}; + +!function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.Report = void 0; + e.Report = class { + constructor(e, t) { + this.name = e, this.value = t; + } + getName() { + return this.name; + } + getValue() { + return this.value; + } + }; +}(ud); + +var ad = {}, cd = {}, ld = {}; + +!function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.replacer = void 0, e.replacer = function(e, t) { + if (t instanceof Map) { + const e = Object.create(null); + return t.forEach(((t, r) => { + e[r] = t; + })), e; + } + if (t instanceof Set) { + const e = []; + return t.forEach((t => { + e.push(t); + })), e; + } + return t; + }; +}(ld), function(e) { + var r = E && E.__importDefault || function(e) { + return e && e.__esModule ? e : { + default: e + }; + }; + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.LocalFileWriter = void 0; + const n = r(ao), i = r(t), o = ld; + class s { + constructor() { + this._replacer = o.replacer, this._space = 2; + } + withSpace(e) { + this._space = e; + } + withReplacer(e) { + this._replacer = e; + } + write(e, t) { + this.writeStr(e, JSON.stringify(t, this._replacer, this._space)); + } + writeStr(e, t) { + const r = i.default.dirname(e); + n.default.existsSync(r) || n.default.mkdirSync(r, { + recursive: !0 + }), n.default.writeFileSync(e, t); + } + static getInstance() { + return s.instance || (s.instance = new s), s.instance; + } + } + e.LocalFileWriter = s; +}(cd); + +var fd = {}, dd = {}; + +!function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.getExtraConfig = e.setExtraConfig = void 0; + let t = new Map; + e.setExtraConfig = function(e) { + t = e; + }, e.getExtraConfig = function(e) { + return t.get(e); + }; +}(dd), function(e) { + var n = E && E.__importDefault || function(e) { + return e && e.__esModule ? e : { + default: e + }; + }; + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.PathUtil = void 0; + const i = n(ao), o = n(t), s = n(r), u = dd, a = qt, c = Zt, l = Eo; + class f { + static getHvigorCacheDir(e) { + var t; + let r = void 0 !== s.default.env.config ? JSON.parse(s.default.env.config)[a.BUILD_CACHE_DIR] : null !== (t = (0, + u.getExtraConfig)(a.BUILD_CACHE_DIR)) && void 0 !== t ? t : f.getCommandHvigorCacheDir(); + const n = o.default.resolve(c.HVIGOR_PROJECT_ROOT_DIR, a.HVIGOR_USER_HOME_DIR_NAME); + return r || (r = l.HvigorConfigLoader.getInstance().getPropertiesConfigValue(a.HVIGOR_CACHE_DIR_KEY), + r) ? o.default.isAbsolute(r) ? (e && !this.hvigorCacheDirHasLogged && (e.warn("Please ensure no projects of the same name have the same custom hvigor data dir."), + this.hvigorCacheDirHasLogged = !0), o.default.resolve(r, o.default.basename(s.default.cwd()), a.HVIGOR_USER_HOME_DIR_NAME)) : (e && !this.hvigorCacheDirHasLogged && (e.warn(`Invalid custom hvigor data dir:${r}`), + this.hvigorCacheDirHasLogged = !0), n) : n; + } + static checkCopyPathIsSame(e, t) { + const r = f.getStatsSync(e), n = f.getStatsSync(t); + return !(!n || !r || !f.areIdentical(r, n)); + } + static getStatsSync(e) { + let t; + try { + t = i.default.statSync(e); + } catch (e) { + return null; + } + return t; + } + static areIdentical(e, t) { + return t.ino && t.dev && t.ino === e.ino && t.dev === e.dev; + } + static getCommandHvigorCacheDir() { + return s.default.argv.forEach((e => { + e.startsWith(a.BUILD_CACHE_DIR) && (s.default.env.BUILD_CACHE_DIR = e.substring(e.indexOf("=") + 1)); + })), s.default.env.BUILD_CACHE_DIR; + } + static getReportDirPath() { + return o.default.resolve(f.getHvigorCacheDir(), "report"); + } + } + e.PathUtil = f, f.hvigorCacheDirHasLogged = !1; +}(fd); + +var pd = {}, hd = {}; + +!function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.addCustomPlugin = e.addCustomTask = e.hvigorTrace = void 0; + const t = Yf; + e.hvigorTrace = { + totalTime: 0, + moduleNum: 0, + taskTime: {}, + isIncremental: !0, + hasIncremental: !1, + isParallel: !0, + IS_DAEMON: !0, + LOG_LEVEL: t.levels.INFO.levelStr, + IS_HVIGORFILE_TYPE_CHECK: !1 + }, e.addCustomTask = function(t) { + var r; + let n = null !== (r = e.hvigorTrace.CUSTOM_TASKS) && void 0 !== r ? r : []; + n.length > 0 && (n = n.filter((e => e.NAME !== t.NAME))), n.push(t), e.hvigorTrace.CUSTOM_TASKS = n; + }, e.addCustomPlugin = function(t) { + var r; + let n = null !== (r = e.hvigorTrace.CUSTOM_PLUGINS) && void 0 !== r ? r : []; + n.length > 0 && (n = n.filter((e => e.PLUGIN_ID !== t.PLUGIN_ID))), n.push({ + PLUGIN_ID: t.PLUGIN_ID + }), e.hvigorTrace.CUSTOM_PLUGINS = n; + }; +}(hd); + +var Ed, Dd, md = {}; + +function gd() { + return Ed || (Ed = 1, function(e) { + var t, r; + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.resetStartData = e.initStartData = e.startEnvironment = e.defaultStartEnvironment = e.globalData = void 0; + const n = Yf, i = qt, o = Eo, s = hd, u = md, a = Hd(), c = Do; + e.globalData = new class { + init(e, t) { + this.cliEnv = e, this.cliOpts = t, this.buildId = function() { + const e = new Date, t = `${e.getFullYear()}${`0${e.getMonth() + 1}`.slice(-2)}${`0${e.getDate()}`.slice(-2)}${`0${e.getHours()}`.slice(-2)}${`0${e.getMinutes()}`.slice(-2)}${`0${e.getSeconds()}`.slice(-2)}${`00${e.getMilliseconds()}`.slice(-3)}`; + return t !== E ? (E = t, D = 0) : D++, `${t}${D}`; + }(); + } + clean() { + this.buildId = void 0; + } + }; + const l = { + pageType: "page", + product: "default", + buildRoot: ".test", + unitTestMode: "true", + isLocalTest: "true", + "ohos-test-coverage": "true", + "unit.test.replace.page": "../../../.test/testability/pages/Index" + }, f = { + product: "default", + buildMode: "test", + "ohos-test-coverage": "true" + }; + function d() { + const e = o.HvigorConfigLoader.getInstance(); + c.coreParameter.properties.hvigorPoolMaxSize = p(e.getPropertiesConfigValue(i.HVIGOR_POOL_MAX_SIZE)), + c.coreParameter.properties.hvigorPoolMaxCoreSize = p(e.getPropertiesConfigValue(i.HVIGOR_POOL_MAX_CORE_SIZE)), + c.coreParameter.properties.hvigorPoolCacheCapacity = p(e.getPropertiesConfigValue(i.HVIGOR_POOL_CACHE_CAPACITY)), + c.coreParameter.properties.hvigorPoolCacheTtl = p(e.getPropertiesConfigValue(i.HVIGOR_POOL_CACHE_TTL)), + c.coreParameter.properties.ohosArkCompileMaxSize = p(e.getPropertiesConfigValue(i.OHOS_ARK_COMPILE_MAX_SIZE)); + } + function p(e) { + if (!("string" == typeof e || void 0 === e || e < 0)) { + return Math.floor(e); + } + } + function h(e) { + const t = new Map; + return e ? (("string" == typeof e ? [ e ] : e).forEach((e => { + const [r, n] = e.split("="), i = "coverage" === r ? "ohos-test-coverage" : r; + t.set(i, n); + })), t) : t; + } + e.defaultStartEnvironment = { + nodeHome: null !== (t = process.env.NODE_HOME) && void 0 !== t ? t : "", + workspaceDir: null !== (r = process.env.WORKSPACE_DIR) && void 0 !== r ? r : "" + }, e.startEnvironment = { + ...e.defaultStartEnvironment + }, e.initStartData = function(t) { + o.HvigorConfigLoader.init(t), function(t) { + if (!t) { + return; + } + const r = new Map; + void 0 !== t.prop && [ t.prop ].flat(2).forEach((e => { + var t; + const n = e.split("="); + r.set(n[0], null === (t = null == n ? void 0 : n.splice(1)) || void 0 === t ? void 0 : t.join("=")); + })), c.coreParameter.extParams = Object.fromEntries(r.entries()), c.coreParameter.workspaceDir = e.startEnvironment.workspaceDir; + }(t), d(), function() { + const t = a.HvigorConfigReader.getHvigorConfig(); + t ? (e.startEnvironment = { + ...e.startEnvironment, + ...t.environment + }, c.coreParameter.properties = { + ...c.defaultProperties, + ...t.properties, + ...c.coreParameter.properties + }, function(e) { + var t, r, n, i, o, s, a, l, f, d; + c.coreParameter.startParams.incrementalExecution = null !== (r = null === (t = e.execution) || void 0 === t ? void 0 : t.incremental) && void 0 !== r ? r : c.coreParameter.startParams.incrementalExecution, + c.coreParameter.startParams.hvigorfileTypeCheck = null !== (i = null === (n = e.execution) || void 0 === n ? void 0 : n.typeCheck) && void 0 !== i ? i : c.coreParameter.startParams.hvigorfileTypeCheck, + c.coreParameter.startParams.parallelExecution = null !== (s = null === (o = e.execution) || void 0 === o ? void 0 : o.parallel) && void 0 !== s ? s : c.coreParameter.startParams.parallelExecution, + c.coreParameter.startParams.daemon = null !== (l = null === (a = e.execution) || void 0 === a ? void 0 : a.daemon) && void 0 !== l ? l : c.coreParameter.startParams.daemon, + c.coreParameter.startParams.printStackTrace = null !== (d = null === (f = e.debugging) || void 0 === f ? void 0 : f.stacktrace) && void 0 !== d ? d : c.coreParameter.startParams.printStackTrace, + function(e) { + var t, r, n; + (null === (t = e.logging) || void 0 === t ? void 0 : t.level) && (c.coreParameter.startParams.logLevel = null !== (n = u.levelMap.get(null === (r = e.logging) || void 0 === r ? void 0 : r.level)) && void 0 !== n ? n : c.coreParameter.startParams.logLevel); + }(e); + }(t)) : c.coreParameter.properties = { + ...c.defaultProperties, + ...c.coreParameter.properties + }; + }(), function(e) { + if (!e) { + return; + } + if (!e._.includes("test")) { + return; + } + e.mode || (e.mode = "module"); + const t = h(e.prop); + Object.keys(l).forEach((e => { + t.has(e) || t.set(e, l[e]); + })); + const r = []; + t.forEach(((e, t) => { + r.push(`${t}=${e}`); + })), e.prop = r; + }(t), function(e) { + if (!e) { + return; + } + if (!e._.includes("onDeviceTest")) { + return; + } + e.mode || (e.mode = "module"); + const t = h(e.prop); + Object.keys(f).forEach((e => { + t.has(e) || t.set(e, f[e]); + })); + const r = []; + t.forEach(((e, t) => { + r.push(`${t}=${e}`); + })), e.prop = r; + }(t), function(t) { + var r, i, o, u, a, l, f; + const d = null != t ? t : e.globalData.cliOpts; + e.startEnvironment.nodeHome = null !== (r = d.nodeHome) && void 0 !== r ? r : e.startEnvironment.nodeHome, + c.coreParameter.startParams.hvigorfileTypeCheck = null !== (i = d.enableBuildScriptTypeCheck) && void 0 !== i ? i : c.coreParameter.startParams.hvigorfileTypeCheck, + c.coreParameter.startParams.hvigorfileTypeCheck = null !== (o = d.typeCheck) && void 0 !== o ? o : c.coreParameter.startParams.hvigorfileTypeCheck, + c.coreParameter.startParams.daemon = null !== (u = d.daemon) && void 0 !== u ? u : c.coreParameter.startParams.daemon, + c.coreParameter.startParams.printStackTrace = null !== (a = d.stacktrace) && void 0 !== a ? a : c.coreParameter.startParams.printStackTrace, + c.coreParameter.startParams.logLevel = d.debug ? n.levels.DEBUG : d.warn ? n.levels.WARN : d.error ? n.levels.ERROR : d.info ? n.levels.INFO : c.coreParameter.startParams.logLevel, + s.hvigorTrace.isParallel = c.coreParameter.startParams.parallelExecution = null !== (l = d.parallel) && void 0 !== l ? l : c.coreParameter.startParams.parallelExecution, + s.hvigorTrace.isIncremental = c.coreParameter.startParams.incrementalExecution = null !== (f = d.incremental) && void 0 !== f ? f : c.coreParameter.startParams.incrementalExecution, + s.hvigorTrace.IS_DAEMON = c.coreParameter.startParams.daemon, s.hvigorTrace.LOG_LEVEL = c.coreParameter.startParams.logLevel.levelStr, + s.hvigorTrace.IS_HVIGORFILE_TYPE_CHECK = c.coreParameter.startParams.hvigorfileTypeCheck; + }(t), d(); + }, e.resetStartData = function() { + e.startEnvironment = { + ...e.defaultStartEnvironment + }, c.coreParameter.clean(); + }; + let E = "", D = 0; + }(pd)), pd; +} + +!function(e) { + var r = E && E.__importDefault || function(e) { + return e && e.__esModule ? e : { + default: e + }; + }; + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.levelMap = e.getLevel = e.setCategoriesLevel = e.updateConfiguration = e.getConfiguration = e.setConfiguration = e.logFilePath = void 0; + const n = Yf, i = r(t), o = fd, s = Zt, u = qt; + e.logFilePath = () => { + let e; + try { + e = o.PathUtil.getHvigorCacheDir(); + } catch { + e = i.default.resolve(s.HVIGOR_PROJECT_ROOT_DIR, u.HVIGOR_USER_HOME_DIR_NAME); + } + return i.default.resolve(e, "./outputs/build-logs"); + }; + let a = { + appenders: { + debug: { + type: "stdout", + layout: { + type: "pattern", + pattern: "[%d] > hvigor %p %c %[%m%]" + } + }, + "debug-log-file": { + type: "file", + filename: i.default.resolve((0, e.logFilePath)(), "build.log"), + maxLogSize: 2097152, + backups: 9, + encoding: "utf-8", + level: "debug" + }, + info: { + type: "stdout", + layout: { + type: "pattern", + pattern: "[%d] > hvigor %[%m%]" + } + }, + "no-pattern-info": { + type: "stdout", + layout: { + type: "pattern", + pattern: "%m" + } + }, + wrong: { + type: "stderr", + layout: { + type: "pattern", + pattern: "[%d] > hvigor %[%p: %m%]" + } + }, + "just-debug": { + type: "logLevelFilter", + appender: "debug", + level: "debug", + maxLevel: "debug" + }, + "just-info": { + type: "logLevelFilter", + appender: "info", + level: "info", + maxLevel: "info" + }, + "just-wrong": { + type: "logLevelFilter", + appender: "wrong", + level: "warn", + maxLevel: "error" + } + }, + categories: { + default: { + appenders: [ "just-debug", "just-info", "just-wrong" ], + level: "debug" + }, + "no-pattern-info": { + appenders: [ "no-pattern-info" ], + level: "info" + }, + "debug-file": { + appenders: [ "debug-log-file" ], + level: "debug" + } + } + }; + e.setConfiguration = e => { + a = e; + }; + e.getConfiguration = () => a; + e.updateConfiguration = () => { + const t = a.appenders["debug-log-file"]; + return t && "filename" in t && (t.filename = i.default.resolve((0, e.logFilePath)(), "build.log")), + a; + }; + let c = n.levels.DEBUG; + e.setCategoriesLevel = (e, t) => { + c = e; + const r = a.categories; + for (const n in r) { + (null == t ? void 0 : t.includes(n)) || n.includes("file") || Object.prototype.hasOwnProperty.call(r, n) && (r[n].level = e.levelStr); + } + }; + e.getLevel = () => c, e.levelMap = new Map([ [ "ALL", n.levels.ALL ], [ "MARK", n.levels.MARK ], [ "TRACE", n.levels.TRACE ], [ "DEBUG", n.levels.DEBUG ], [ "INFO", n.levels.INFO ], [ "WARN", n.levels.WARN ], [ "ERROR", n.levels.ERROR ], [ "FATAL", n.levels.FATAL ], [ "OFF", n.levels.OFF ], [ "all", n.levels.ALL ], [ "mark", n.levels.MARK ], [ "trace", n.levels.TRACE ], [ "debug", n.levels.DEBUG ], [ "info", n.levels.INFO ], [ "warn", n.levels.WARN ], [ "error", n.levels.ERROR ], [ "fatal", n.levels.FATAL ], [ "off", n.levels.OFF ] ]); +}(md); + +var vd = {}, yd = {}; + +!function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.MapCacheService = void 0; + e.MapCacheService = class { + constructor() { + this.cacheEntryMap = new Map; + } + initialize() {} + close() { + this.cacheEntryMap.clear(); + } + get(e) { + return this.cacheEntryMap.get(e); + } + remove(e) { + this.cacheEntryMap.delete(e); + } + size() { + return this.cacheEntryMap.size; + } + }; +}(yd), function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.MetricCacheService = void 0; + const t = yd; + class r extends t.MapCacheService { + constructor() { + super(); + } + add(e) { + this.cacheEntryMap.set(e.getId(), e); + } + getEvents() { + const e = []; + return this.cacheEntryMap.forEach((t => { + e.push(t); + })), e; + } + static getInstance() { + return r.instance || (r.instance = new r), r.instance; + } + } + e.MetricCacheService = r; +}(vd); + +var Cd, Ad, Fd, Sd = {}; + +function Od() { + return Cd || (Cd = 1, function(e) { + Object.defineProperty(e, "__esModule", { + value: !0 + }), e.DurationEvent = e.DurationEventState = void 0; + const t = jd(), r = Md(), n = wd(), i = nd, o = _d(), s = rd; + var u; + !function(e) { + e.CREATED = "created", e.BEGINNING = "beginning", e.RUNNING = "running", e.FAILED = "failed", + e.SUCCESS = "success", e.WARN = "warn"; + }(u = e.DurationEventState || (e.DurationEventState = {})); + class a { + constructor(e, t) { + this.children = [], this.state = u.CREATED, this.targetName = "", this.moduleName = ""; + const r = e.indexOf(":"); + if (r > 0) { + this.moduleName = e.substring(0, r); + const t = e.indexOf("@"); + t > 0 && (this.targetName = e.substring(r + 1, t)); + } + this.category = t, this.taskRunReasons = []; + } + } + class c extends i.BaseEvent { + constructor(e, r, n, o, s, u) { + super(new i.EventHead(e, r, n, i.MetricEventType.DURATION), new i.EventBody(o, u)), + this.log = t.HvigorLogger.getLogger("DurationEvent"), this.additional = new a(r, s); + } + start(e = u.RUNNING, t) { + return this.setState(e), super.setStartTime(t), this; + } + stop(e = u.SUCCESS, t) { + if (this.additional.state === u.FAILED || this.additional.state === u.SUCCESS || this.additional.state === u.WARN) { + return this; + } + this.body.endTime = null != t ? t : Number(process.hrtime.bigint()); + const r = n.MetricService.getInstance(); + this.setState(e); + for (const t of this.additional.children) { + const n = r.getEventById(t); + n ? n instanceof c ? n.stop(e) : this.log.warn(`Child:'${t}' is not of type DurationEvent.`) : this.log.warn(`Can not getEventById:'${t}' from MetricCacheService.`); + } + return this; + } + setState(e) { + this.additional.state = e; + } + createSubEvent(e, t) { + const n = r.MetricFactory.createDurationEvent(e, t, ""); + return n.setParent(this.getId()), this.addChild(n.getId()), n; + } + addChild(e) { + this.additional.children.push(e); + } + setParent(e) { + this.additional.parent = e; + } + getParent() { + return this.additional.parent; + } + getChildren() { + return this.additional.children; + } + setLog(e, t = s.MetricLogType.INFO, n, i) { + const o = r.MetricFactory.createLogEvent(null != e ? e : this.head.name, t, this.getTid(), n); + o.setDurationId(this.getId()), this.additional.logId = o.getId(), o.setStartTime(this.body.startTime), + o.setEndTime(this.body.endTime), i && o.setTotalTime(i), this.setParentLog(o), this.setChildrenLog(o); + } + setParentLog(e) { + const t = n.MetricService.getInstance().getEventById(this.additional.parent); + if (t instanceof c) { + const r = n.MetricService.getInstance().getEventById(t.additional.logId); + r instanceof s.LogEvent && (r.addChild(e.getId()), e.setParent(r.getId())); + } + } + setChildrenLog(e) { + this.additional.children.forEach((t => { + const r = n.MetricService.getInstance().getEventById(t); + if (r instanceof c || r instanceof o.ContinualEvent) { + e.addChild(r.additional.logId); + const t = n.MetricService.getInstance().getEventById(r.additional.logId); + t instanceof s.LogEvent && r.setParentLog(t); + } + })); + } + setDetail(e) { + const t = r.MetricFactory.createLogEvent(e, s.MetricLogType.DETAIL, this.getTid()); + t.setDurationId(this.getId()), this.additional.detailId = t.getId(); + } + setCategory(e) { + this.additional.category = e; + } + addTaskRunReason(e) { + this.additional.taskRunReasons.push(e); + } + } + e.DurationEvent = c; + }(Sd)), Sd; +} + +function wd() { + return Ad || (Ad = 1, function(r) { + Object.defineProperty(r, "__esModule", { + value: !0 + }), r.MetricService = void 0; + const n = ud, i = (Dd || (Dd = 1, function(r) { + var n = E && E.__importDefault || function(e) { + return e && e.__esModule ? e : { + default: e + }; + }; + Object.defineProperty(r, "__esModule", { + value: !0 + }), r.ReportServiceImpl = void 0; + const i = n(e), o = n(ao), s = n(t), u = cd, a = fd, c = Do; + class l { + constructor() { + this.reportListeners = []; + } + report() { + const e = this.getReport(), t = a.PathUtil.getReportDirPath(); + i.default.existsSync(t) || i.default.mkdirSync(t, { + recursive: !0 + }), this.deleteUnusableFiles(t), this.storage(e, t); + } + getReport() { + const e = { + version: "2.0", + ppid: process.ppid + }; + for (const t of this.reportListeners) { + const r = t.queryReport(); + e[r.getName()] = r.getValue(); + } + return e; + } + storage(e, t) { + const r = i.default.readdirSync(t).filter((e => e.startsWith("report-") && e.endsWith("json"))).sort(((e, r) => { + const n = s.default.resolve(t, e), o = s.default.resolve(t, r), u = i.default.statSync(n); + return i.default.statSync(o).birthtimeMs - u.birthtimeMs; + })); + for (let e = 0; e < r.length; e++) { + if (e >= 9) { + const n = s.default.resolve(t, r[e]); + i.default.existsSync(n) && i.default.unlinkSync(n); + } + } + const n = gd(); + if (void 0 === n.globalData.buildId) { + return; + } + let o = n.globalData.buildId; + const a = s.default.resolve(t, `report-${o}.json`); + u.LocalFileWriter.getInstance().write(a, e), f() && this.generateHtmlResource(t, `report-${o}`, e); + } + deleteUnusableFiles(e) { + i.default.readdirSync(e).forEach((t => { + if (!l.REPORT_REG.test(t) && (!l.HTML_REG.test(t) || f()) && t !== l.HTML_RESOURCE_NAME) { + const r = s.default.resolve(e, t); + i.default.existsSync(r) && i.default.unlinkSync(r); + } + })); + } + addListener(e) { + this.reportListeners.push(e); + } + removeListener(e) { + const t = this.reportListeners.indexOf(e); + -1 !== t && this.reportListeners.splice(t, 1); + } + generateHtmlResource(e, t, r) { + const n = s.default.resolve(e, "htmlResource"), u = s.default.resolve(__filename, "../../../../../res/staticHtmlResource/htmlResource"); + if (i.default.existsSync(n)) { + const e = i.default.readdirSync(u), t = i.default.readdirSync(n); + e.every((e => !!t.includes(e) && i.default.statSync(s.default.resolve(u, e)).size === i.default.statSync(s.default.resolve(n, e)).size)) || o.default.copySync(u, n); + } else { + o.default.copySync(u, n); + } + const a = s.default.resolve(__filename, "../../../../../res/staticHtmlResource/index.html"), c = i.default.readFileSync(a, "utf8"), l = ` + + + + + +
+ + + + + + diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/exit.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/exit.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..42f79a9dbbd6dde75519a453799323dc8afb6878 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/exit.d.ts @@ -0,0 +1,6 @@ +/** + * 等待输出流中的内容排空后再执行退出 + * + * @param code exitCode + */ +export declare function exit(code: number): void; diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/exit.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/exit.js new file mode 100755 index 0000000000000000000000000000000000000000..69553259a9f60a9cb49a9117b52f99d3f84e4f31 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/exit.js @@ -0,0 +1 @@ +"use strict";function exit(e){"win32"===process.platform&&process.stdout.writableLength?process.stdout.once("drain",(function(){process.exit(e)})):process.exit(e)}Object.defineProperty(exports,"__esModule",{value:!0}),exports.exit=void 0,exports.exit=exit; \ No newline at end of file diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/init-env-config-props.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/init-env-config-props.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..c1e334656bcafdca054c23a47029fa888923218b --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/init-env-config-props.d.ts @@ -0,0 +1,6 @@ +/** + * 加载liftOff获取到的configFiles中的具体一个配置文件的路径 + * + * @return {string} path 返回cwd的路径 + */ +export declare function initEnvConfigProps(): void; diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/init-env-config-props.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/init-env-config-props.js new file mode 100755 index 0000000000000000000000000000000000000000..5f460f9eea3987d23cd96c3bcfad7b24f9f8377a --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/init-env-config-props.js @@ -0,0 +1 @@ +"use strict";var __importDefault=this&&this.__importDefault||function(o){return o&&o.__esModule?o:{default:o}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.initEnvConfigProps=void 0;const fs_1=__importDefault(require("fs")),os_1=__importDefault(require("os")),path_1=__importDefault(require("path")),process_1=__importDefault(require("process")),common_const_js_1=require("../../common/options/common-const.js"),global_data_js_1=require("../../internal/data/global-data.js"),hvigor_log_js_1=require("../../log/hvigor-log.js"),configFileName=common_const_js_1.HvigorCommonConst.BUILD_PROFILE_FILE_NAME,propertiesAlias="prop",modeAlias="mode",_log=hvigor_log_js_1.HvigorLogger.getLogger("hvigor-InitEnvConfigProps");function initEnvConfigProps(){const o=global_data_js_1.globalData.cliOpts,t=global_data_js_1.globalData.cliEnv,e=path_1.default.resolve(process_1.default.cwd(),common_const_js_1.HvigorCommonConst.BUILD_PROFILE_FILE);fs_1.default.existsSync(e)||_log.errorMessageExit(`Cannot find project build file '${common_const_js_1.HvigorCommonConst.BUILD_PROFILE_FILE}'\n ${os_1.default.EOL}\t at ${t.cwd}`);const s=new Map;void 0!==o.prop&&[o.prop].flat(2).forEach((o=>{const t=o.split("=");s.set(t[0],t[1])})),t.configProps=new Map([[configFileName,e],["prop",s],["mode",o.mode]])}exports.initEnvConfigProps=initEnvConfigProps; \ No newline at end of file diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/require-hook.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/require-hook.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..db498fd21defa4881b45b770958dc2e934bf61b3 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/require-hook.d.ts @@ -0,0 +1 @@ +export declare function addExtensionHandler(suffixes: string[]): void; diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/require-hook.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/require-hook.js new file mode 100755 index 0000000000000000000000000000000000000000..59cde4baa3d49d130e6184657877e87844bf5f7c --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/hooks/require-hook.js @@ -0,0 +1 @@ +"use strict";var __createBinding=this&&this.__createBinding||(Object.create?function(e,t,r,o){void 0===o&&(o=r);var i=Object.getOwnPropertyDescriptor(t,r);i&&!("get"in i?!t.__esModule:i.writable||i.configurable)||(i={enumerable:!0,get:function(){return t[r]}}),Object.defineProperty(e,o,i)}:function(e,t,r,o){void 0===o&&(o=r),e[o]=t[r]}),__setModuleDefault=this&&this.__setModuleDefault||(Object.create?function(e,t){Object.defineProperty(e,"default",{enumerable:!0,value:t})}:function(e,t){e.default=t}),__importStar=this&&this.__importStar||function(e){if(e&&e.__esModule)return e;var t={};if(null!=e)for(var r in e)"default"!==r&&Object.prototype.hasOwnProperty.call(e,r)&&__createBinding(t,e,r);return __setModuleDefault(t,e),t},__importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.addExtensionHandler=void 0;const fs_1=__importDefault(require("fs")),module_1=__importDefault(require("module")),path=__importStar(require("path")),typescript_1=__importDefault(require("typescript")),ts_check_js_1=require("../../internal/util/ts_check.js"),hvigor_log_js_1=require("../../log/hvigor-log.js"),compile_options_js_1=require("../../util/options/compile-options.js"),log=hvigor_log_js_1.HvigorLogger.getLogger("require_hook"),to={compilerOptions:compile_options_js_1.compilerOptions,reportDiagnostics:!0};function extensionHandler(e,t){const r=path.resolve(__dirname,t),o=fs_1.default.readFileSync(r,"utf-8"),i=typescript_1.default.transpileModule(o,to);handleDiagnostics(r,i.diagnostics),e._compile(i.outputText,t)}function handleDiagnostics(e,t){const r={getCanonicalFileName:e=>e,getCurrentDirectory:typescript_1.default.sys.getCurrentDirectory,getNewLine:()=>typescript_1.default.sys.newLine};null==t||t.forEach((t=>{log.error((0,ts_check_js_1.formatDiagnostic)(t,r,e))})),(null==t?void 0:t.length)&&log.errorMessageExit("Please fix above syntax errors.")}function addExtensionHandler(e){for(const t of e)module_1.default._extensions[t]=extensionHandler}exports.addExtensionHandler=addExtensionHandler,addExtensionHandler([".ts",".mjs"]); \ No newline at end of file diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/index.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/index.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..60ac4c9ab7eb1b21c3b6af61dfe610e11de61ca0 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/index.d.ts @@ -0,0 +1,2 @@ +import { HvigorCliOptions } from '../util/options/hvigor-cli-options.js'; +export declare function boot(opts: HvigorCliOptions): Promise; diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/index.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/index.js new file mode 100755 index 0000000000000000000000000000000000000000..d59b2d10453a47375f0a78172256d6f15e1236bb --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/boot/index.js @@ -0,0 +1 @@ +"use strict";var __importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.boot=void 0;const process_1=__importDefault(require("process")),wrapper_const_js_1=require("../../cli/wrapper/wrapper-const.js"),hook_const_js_1=require("../../common/const/hook-const.js"),hvigor_js_1=require("../external/core/hvigor.js"),core_task_js_1=require("../external/task/core-task.js"),global_data_js_1=require("../internal/data/global-data.js"),build_task_graph_js_1=require("../internal/lifecycle/build-task-graph.js"),configuration_js_1=require("../internal/lifecycle/configuration.js"),execute_mode_factory_js_1=require("../internal/lifecycle/execute/mode/execute-mode-factory.js"),hvigor_lifecycle_hook_js_1=require("../internal/lifecycle/hook/hvigor-lifecycle-hook.js"),hvigor_process_js_1=require("../internal/lifecycle/hvigor-process.js"),init_js_1=require("../internal/lifecycle/init.js"),log_event_js_1=require("../metrics/event/log-event.js"),metric_factory_js_1=require("../metrics/metric-factory.js"),init_env_config_props_js_1=require("./hooks/init-env-config-props.js"),require_hook_js_1=require("./hooks/require-hook.js"),modeAlias="mode";async function boot(e){try{(0,require_hook_js_1.addExtensionHandler)([".ts",".mjs"]);const o={cwd:process_1.default.cwd(),configProps:null,version:wrapper_const_js_1.CUR_HVIGOR_VERSION};global_data_js_1.globalData.init(o,e),(0,init_env_config_props_js_1.initEnvConfigProps)(),hvigor_process_js_1.hvigorProcess.init(),hvigor_process_js_1.hvigorProcess.setTaskBeginTime(),await start()}catch(e){e instanceof Error&&hvigor_process_js_1.hvigorProcess.error(e)}}async function start(){const e="init",o="create hvigor project model",t="configure hvigor plugin",r="build task graph",i="init task execution option",s=metric_factory_js_1.MetricFactory.createDurationEvent(e,"Initialize and build task graph.",core_task_js_1.HvigorTaskGroupType.INIT_TASK_GROUP),_=s.createSubEvent(o,"Initialize hvigor project model."),a=s.createSubEvent(t,"Configure hvigor plugin."),n=s.createSubEvent(r,"Build task graph."),c=s.createSubEvent(i,"Init task execution option.");s.start(),_.start();const l=global_data_js_1.globalData.cliOpts,g=global_data_js_1.globalData.cliEnv;await(0,init_js_1.init)(),_.stop().setLog(o,log_event_js_1.MetricLogType.INFO),a.start();const u=await(0,configuration_js_1.configuration)(a);a.stop().setLog(t,log_event_js_1.MetricLogType.INFO),n.start(),(0,build_task_graph_js_1.buildTaskGraph)(u),await hvigor_lifecycle_hook_js_1.HvigorLifecycleHook.getInstance().runHook(hook_const_js_1.HookType.taskGraphResolved,hvigor_js_1.hvigor),n.stop().setLog(r,log_event_js_1.MetricLogType.INFO),c.start();const p={toRunTasks:l._,isNeedSync:!!l.sync};c.stop().setLog(i,log_event_js_1.MetricLogType.INFO),s.stop().setLog(e,log_event_js_1.MetricLogType.INFO);const j=g.configProps.get(modeAlias);await new execute_mode_factory_js_1.ExecuteModeFactory(u,p).getExecutePipeline(j).startPipeline()}exports.boot=boot; \ No newline at end of file diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/build-event.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/build-event.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..729bd46e80c9d2ce6aeb67be056614ce5d10cd24 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/build-event.d.ts @@ -0,0 +1,17 @@ +export declare enum BuildEvent { + COMMON_BUILD = "CommonBuild", + CANCEL_BUILD = "CancelBuild", + STOP_DAEMON = "StopDaemon", + OUTPUT = "Output", + BUILD_STATUS = "BuildStatus" +} +export declare enum WatchEvent { + WATCH_START = "WatchStart", + WATCH_RESULT = "WatchResult", + CLOSE_WATCH = "CloseWatch", + WATCH_COMPILE_RESULT = "WatchCompileResult", + WATCH_COMPILE_DATA = "WatchCompileData", + WATCH_LOG = "WatchLog", + TERMINATE_WORKER = "TerminateWorker", + NEW_WATCH_WORKER = "NewWatchWorker" +} diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/build-event.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/build-event.js new file mode 100755 index 0000000000000000000000000000000000000000..0fb5a7079c5a97e9c8b8296dca6490167530d920 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/build-event.js @@ -0,0 +1 @@ +"use strict";var BuildEvent,WatchEvent;Object.defineProperty(exports,"__esModule",{value:!0}),exports.WatchEvent=exports.BuildEvent=void 0,function(t){t.COMMON_BUILD="CommonBuild",t.CANCEL_BUILD="CancelBuild",t.STOP_DAEMON="StopDaemon",t.OUTPUT="Output",t.BUILD_STATUS="BuildStatus"}(BuildEvent=exports.BuildEvent||(exports.BuildEvent={})),function(t){t.WATCH_START="WatchStart",t.WATCH_RESULT="WatchResult",t.CLOSE_WATCH="CloseWatch",t.WATCH_COMPILE_RESULT="WatchCompileResult",t.WATCH_COMPILE_DATA="WatchCompileData",t.WATCH_LOG="WatchLog",t.TERMINATE_WORKER="TerminateWorker",t.NEW_WATCH_WORKER="NewWatchWorker"}(WatchEvent=exports.WatchEvent||(exports.WatchEvent={})); \ No newline at end of file diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/common-enum.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/common-enum.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..5d002e2fcc34d531f15dea7464d4812e1ed44943 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/common-enum.d.ts @@ -0,0 +1,18 @@ +export declare enum OutputType { + SYSTEM = "system", + STDOUT = "stdout", + STDERR = "stderr" +} +export declare enum BuildStatus { + FINISH = "finish", + BEGIN = "begin", + RUNNING = "running", + CLOSE = "close", + REJECT = "reject" +} +export declare enum LogLevel { + DEBUG = "debug", + INFO = "info", + WARN = "warn", + ERROR = "error" +} diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/common-enum.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/common-enum.js new file mode 100755 index 0000000000000000000000000000000000000000..3a59fcca4167d3fe8265b5957d30a344978e0fc9 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/common-enum.js @@ -0,0 +1 @@ +"use strict";var OutputType,BuildStatus,LogLevel;Object.defineProperty(exports,"__esModule",{value:!0}),exports.LogLevel=exports.BuildStatus=exports.OutputType=void 0,function(t){t.SYSTEM="system",t.STDOUT="stdout",t.STDERR="stderr"}(OutputType=exports.OutputType||(exports.OutputType={})),function(t){t.FINISH="finish",t.BEGIN="begin",t.RUNNING="running",t.CLOSE="close",t.REJECT="reject"}(BuildStatus=exports.BuildStatus||(exports.BuildStatus={})),function(t){t.DEBUG="debug",t.INFO="info",t.WARN="warn",t.ERROR="error"}(LogLevel=exports.LogLevel||(exports.LogLevel={})); \ No newline at end of file diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/message.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/message.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..39ef068c8e64cb65b5d261796a6a2bf178837d9c --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/message.d.ts @@ -0,0 +1,20 @@ +/// +import { BuildStatus, OutputType } from './common-enum.js'; +export type Message = object; +export interface OutputMessage extends Message { + type: OutputType; + text: string | Uint8Array; + encoding?: BufferEncoding; +} +export declare function createOutput(type: OutputType, text: string | Uint8Array, encoding?: BufferEncoding): OutputMessage; +export interface BuildStatusMessage extends Message { + status: BuildStatus; + exitCode?: number; + reason?: string; +} +export declare function createBuildStatus(status: BuildStatus, exitCode?: number, reason?: string): BuildStatusMessage; +export interface Command extends Message { + reason: string; +} +export type CancelBuildCommand = Command; +export type StopDaemonCommand = Command; diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/message.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/message.js new file mode 100755 index 0000000000000000000000000000000000000000..4eff824051331852451dc2bf255cece1e41f19e2 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/daemon-protocol/message.js @@ -0,0 +1 @@ +"use strict";function createOutput(t,e,u){return{type:t,text:e,encoding:u}}function createBuildStatus(t,e,u){return{status:t,exitCode:e,reason:u}}Object.defineProperty(exports,"__esModule",{value:!0}),exports.createBuildStatus=exports.createOutput=void 0,exports.createOutput=createOutput,exports.createBuildStatus=createBuildStatus; \ No newline at end of file diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/class-type-const.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/class-type-const.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..315dce41faa37a31df52d6a2377ec5e5dd857f32 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/class-type-const.d.ts @@ -0,0 +1,12 @@ +/** + * 由于直接使用js的instanceOf不太方便，以及规避不了一些原生的问题，比如import 循环 + * 故使用给不同类型的类增加一个标识来判断 + * 以下包含Hvigor中用来区分一些工程结构的对象类型的属性值 + * + * @since 2022/6/20 + */ +export declare class ClassTypeConst { + static readonly HVIGOR_NODE: string; + static readonly HVIGOR_PROJECT: string; + static readonly HVIGOR_MODULE: string; +} diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/class-type-const.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/class-type-const.js new file mode 100755 index 0000000000000000000000000000000000000000..7fddf392b8953aff5dc991da126e944b0bb80114 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/class-type-const.js @@ -0,0 +1 @@ +"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.ClassTypeConst=void 0;class ClassTypeConst{}exports.ClassTypeConst=ClassTypeConst,ClassTypeConst.HVIGOR_NODE="node",ClassTypeConst.HVIGOR_PROJECT="project",ClassTypeConst.HVIGOR_MODULE="module"; \ No newline at end of file diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/common-const.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/common-const.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..1957e473a02de0cc52a254bd5618eb2a6c4c9c4c --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/common-const.d.ts @@ -0,0 +1,23 @@ +/** + * Hvigor工程中需要使用的一些公共参数 + * + * @since 2022/6/18 + */ +export declare class HvigorCommonConst { + static readonly BUILD_PROFILE_FILE_NAME: string; + static readonly BUILD_PROFILE_FILE: string; + static readonly BUILD_FILE_NAME: string; + static readonly PACKAGE_JSON: string; + static readonly BUILD_FILE_NAME_SUFFIX: string[]; + static readonly HVIGOR_CONFIG_FILE_NAME: string; + static readonly HVIGOR_CONFIG_FILE_NAME_SUFFIX: string[]; +} +/** + * Hvigor工程构建生命周期中需要使用的一些公共参数 + * + * @since 2022/6/18 + */ +export declare class HvigorBuildConst { + static readonly MODULE_MODE: string; + static readonly PROJECT_MODE: string; +} diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/common-const.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/common-const.js new file mode 100755 index 0000000000000000000000000000000000000000..182c7c80eda602e42e668cf7ea81a06166f22744 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/common-const.js @@ -0,0 +1 @@ +"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.HvigorBuildConst=exports.HvigorCommonConst=void 0;class HvigorCommonConst{}exports.HvigorCommonConst=HvigorCommonConst,HvigorCommonConst.BUILD_PROFILE_FILE_NAME="build-profile",HvigorCommonConst.BUILD_PROFILE_FILE="build-profile.json5",HvigorCommonConst.BUILD_FILE_NAME="hvigorfile",HvigorCommonConst.PACKAGE_JSON="package.json",HvigorCommonConst.BUILD_FILE_NAME_SUFFIX=[".ts",".js",".cjs",".mjs"],HvigorCommonConst.HVIGOR_CONFIG_FILE_NAME="hvigorconfig",HvigorCommonConst.HVIGOR_CONFIG_FILE_NAME_SUFFIX=[".ts",".js",".cjs",".mjs"];class HvigorBuildConst{}exports.HvigorBuildConst=HvigorBuildConst,HvigorBuildConst.MODULE_MODE="module",HvigorBuildConst.PROJECT_MODE="project"; \ No newline at end of file diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/project-structure-opt.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/project-structure-opt.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..1ae3c6e35d2d29f19e3f330fda33de1f0df3df88 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/project-structure-opt.d.ts @@ -0,0 +1,7 @@ +export interface ModuleOpt { + name: string; + srcPath: string; +} +export interface ProjectStructureOpt { + modules: ModuleOpt[]; +} diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/project-structure-opt.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/project-structure-opt.js new file mode 100755 index 0000000000000000000000000000000000000000..f5d605376efe1eaa3b976504df25bb48b1d76541 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/options/project-structure-opt.js @@ -0,0 +1 @@ +"use strict";Object.defineProperty(exports,"__esModule",{value:!0}); \ No newline at end of file diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-listener.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-listener.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..e803444e961d692ab9987dc3cfe52250c1fb06a9 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-listener.d.ts @@ -0,0 +1,9 @@ +import { Report } from './report.js'; +/** + * 报告服务监听器接口 + * + * @since 2022/8/18 + */ +export interface ReportListener { + queryReport(): Report; +} diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-listener.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-listener.js new file mode 100755 index 0000000000000000000000000000000000000000..f5d605376efe1eaa3b976504df25bb48b1d76541 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-listener.js @@ -0,0 +1 @@ +"use strict";Object.defineProperty(exports,"__esModule",{value:!0}); \ No newline at end of file diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-service-impl.d.ts b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-service-impl.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..dacbc2884defe8a3fb1f91a7b6de92e071ef6870 --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-service-impl.d.ts @@ -0,0 +1,47 @@ +import { ReportListener } from './report-listener.js'; +import { ReportService } from './report-service.js'; +/** + * 报告服务实现类 + * + * @since 2022/8/18 + */ +export declare class ReportServiceImpl implements ReportService { + private reportListeners; + private static instance; + private static MAX_REPEAT_TIMES; + private static REPORT_REG; + private static HTML_REG; + private static HTML_RESOURCE_NAME; + private constructor(); + report(): void; + getReport(): any; + /** + * 存储到report.json + * + * @param reportObj + * @param reportDirPath + */ + storage(reportObj: { + [name: string]: any; + }, reportDirPath: string): void; + /** + * 删除除了report以外的无效文件 + */ + deleteUnusableFiles(reportDirPath: string): void; + /** + * 添加监听 + * + * @param listener + */ + addListener(listener: ReportListener): void; + /** + * 移除监听 + * + * @param listener + */ + removeListener(listener: ReportListener): void; + generateHtmlResource(reportDirPath: string, reportFileName: string, reportObj: { + [name: string]: any; + }): void; + static getInstance(): ReportServiceImpl; +} diff --git a/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-service-impl.js b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-service-impl.js new file mode 100755 index 0000000000000000000000000000000000000000..63c082e2156725421229d10a614c9ab440c4aa8d --- /dev/null +++ b/arkoala-arkts/user/command-line-tools/hvigor/hvigor/src/base/common/report/report-service-impl.js @@ -0,0 +1 @@ +"use strict";var __importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.ReportServiceImpl=void 0;const fs_1=__importDefault(require("fs")),fs_extra_1=__importDefault(require("fs-extra")),path_1=__importDefault(require("path")),local_file_writer_js_1=require("../../../common/util/local-file-writer.js"),path_util_js_1=require("../../../common/util/path-util.js"),global_core_parameters_1=require("../../internal/data/global-core-parameters");class ReportServiceImpl{constructor(){this.reportListeners=[]}report(){const e=this.getReport(),t=path_util_js_1.PathUtil.getReportDirPath();fs_1.default.existsSync(t)||fs_1.default.mkdirSync(t,{recursive:!0}),this.deleteUnusableFiles(t),this.storage(e,t)}getReport(){const e={version:"2.0",ppid:process.ppid};for(const t of this.reportListeners){const r=t.queryReport();e[r.getName()]=r.getValue()}return e}storage(e,t){const r=fs_1.default.readdirSync(t).filter((e=>e.startsWith("report-")&&e.endsWith("json"))).sort(((e,r)=>{const s=path_1.default.resolve(t,e),l=path_1.default.resolve(t,r),a=fs_1.default.statSync(s);return fs_1.default.statSync(l).birthtimeMs-a.birthtimeMs}));for(let e=0;e=9){const s=path_1.default.resolve(t,r[e]);fs_1.default.existsSync(s)&&fs_1.default.unlinkSync(s)}const s=require("../../internal/data/global-data.js");if(void 0===s.globalData.buildId)return;let l=s.globalData.buildId;const a=path_1.default.resolve(t,`report-${l}.json`);local_file_writer_js_1.LocalFileWriter.getInstance().write(a,e),enableHtmlGenerate()&&this.generateHtmlResource(t,`report-${l}`,e)}deleteUnusableFiles(e){fs_1.default.readdirSync(e).forEach((t=>{if(!ReportServiceImpl.REPORT_REG.test(t)&&(!ReportServiceImpl.HTML_REG.test(t)||enableHtmlGenerate())&&t!==ReportServiceImpl.HTML_RESOURCE_NAME){const r=path_1.default.resolve(e,t);fs_1.default.existsSync(r)&&fs_1.default.unlinkSync(r)}}))}addListener(e){this.reportListeners.push(e)}removeListener(e){const t=this.reportListeners.indexOf(e);-1!==t&&this.reportListeners.splice(t,1)}generateHtmlResource(e,t,r){const s=path_1.default.resolve(e,"htmlResource"),l=path_1.default.resolve(__filename,"../../../../../res/staticHtmlResource/htmlResource");if(fs_1.default.existsSync(s)){const e=fs_1.default.readdirSync(l),t=fs_1.default.readdirSync(s);e.every((e=>{if(!t.includes(e))return!1;return fs_1.default.statSync(path_1.default.resolve(l,e)).size===fs_1.default.statSync(path_1.default.resolve(s,e)).size}))||fs_extra_1.default.copySync(l,s)}else fs_extra_1.default.copySync(l,s);const a=path_1.default.resolve(__filename,"../../../../../res/staticHtmlResource/index.html"),i=fs_1.default.readFileSync(a,"utf8"),o=`