@yinuo-ngm/server 1.0.22 → 1.0.24

package/lib/modules/agent-connections/agent-connections.schema.d.ts

@@ -0,0 +1,4 @@
+import type { CreateHubV2ConnectionInput, UpdateHubV2ConnectionInput } from "./agent-connections.types";
+export declare function parseHubV2NameParam(value: unknown): string;
+export declare function parseCreateHubV2ConnectionInput(input: unknown): CreateHubV2ConnectionInput;
+export declare function parseUpdateHubV2ConnectionInput(input: unknown): UpdateHubV2ConnectionInput;

package/lib/modules/agent-connections/agent-connections.schema.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHubV2NameParam = parseHubV2NameParam;
+exports.parseCreateHubV2ConnectionInput = parseCreateHubV2ConnectionInput;
+exports.parseUpdateHubV2ConnectionInput = parseUpdateHubV2ConnectionInput;
+const errors_1 = require("@yinuo-ngm/errors");
+const NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
+function ensureObject(value, message) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, message);
+    }
+    return value;
+}
+function readOptionalString(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, `${fieldName} must be string`);
+    }
+    const text = value.trim();
+    return text || undefined;
+}
+function readRequiredString(value, fieldName) {
+    const text = readOptionalString(value, fieldName);
+    if (!text) {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, `${fieldName} is required`);
+    }
+    return text;
+}
+function ensureValidName(name, fieldName) {
+    if (!NAME_PATTERN.test(name)) {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, `${fieldName} only allows [a-zA-Z0-9._-]`);
+    }
+    return name;
+}
+function ensureHttpUrl(url, fieldName) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            throw new Error("invalid protocol");
+        }
+        return parsed.toString().replace(/\/+$/, "");
+    }
+    catch {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, `${fieldName} must start with http:// or https://`);
+    }
+}
+function readOptionalBoolean(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "boolean") {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, `${fieldName} must be boolean`);
+    }
+    return value;
+}
+function readOptionalNullableString(value, fieldName) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (typeof value !== "string") {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, `${fieldName} must be string|null`);
+    }
+    return value;
+}
+function parseHubV2NameParam(value) {
+    const name = readRequiredString(value, "name");
+    return ensureValidName(name, "name");
+}
+function parseCreateHubV2ConnectionInput(input) {
+    const body = ensureObject(input, "invalid request body");
+    const name = ensureValidName(readRequiredString(body.name, "name"), "name");
+    const baseUrl = ensureHttpUrl(readRequiredString(body.baseUrl, "baseUrl"), "baseUrl");
+    const projectKey = readRequiredString(body.projectKey, "projectKey");
+    const projectName = readOptionalString(body.projectName, "projectName");
+    const projectToken = readOptionalNullableString(body.projectToken, "projectToken");
+    const personalToken = readOptionalNullableString(body.personalToken, "personalToken");
+    const isDefault = readOptionalBoolean(body.isDefault, "isDefault");
+    return {
+        name,
+        baseUrl,
+        projectKey,
+        projectName,
+        projectToken,
+        personalToken,
+        isDefault,
+    };
+}
+function parseUpdateHubV2ConnectionInput(input) {
+    const body = ensureObject(input, "invalid request body");
+    const next = {};
+    if (Object.prototype.hasOwnProperty.call(body, "baseUrl")) {
+        next.baseUrl = ensureHttpUrl(readRequiredString(body.baseUrl, "baseUrl"), "baseUrl");
+    }
+    if (Object.prototype.hasOwnProperty.call(body, "projectKey")) {
+        next.projectKey = readRequiredString(body.projectKey, "projectKey");
+    }
+    if (Object.prototype.hasOwnProperty.call(body, "projectName")) {
+        next.projectName = readOptionalString(body.projectName, "projectName");
+    }
+    if (Object.prototype.hasOwnProperty.call(body, "projectToken")) {
+        next.projectToken = readOptionalNullableString(body.projectToken, "projectToken");
+    }
+    if (Object.prototype.hasOwnProperty.call(body, "personalToken")) {
+        next.personalToken = readOptionalNullableString(body.personalToken, "personalToken");
+    }
+    if (Object.prototype.hasOwnProperty.call(body, "isDefault")) {
+        next.isDefault = readOptionalBoolean(body.isDefault, "isDefault");
+    }
+    return next;
+}

package/lib/modules/agent-connections/agent-connections.service.d.ts

@@ -0,0 +1,18 @@
+import type { CreateHubV2ConnectionInput, ListHubV2ConnectionsResult, UpdateHubV2ConnectionInput } from "./agent-connections.types";
+type AgentConnectionsServiceOptions = {
+    dataDir?: string;
+};
+export declare class AgentConnectionsService {
+    readonly dataDir: string;
+    readonly configPath: string;
+    constructor(options?: AgentConnectionsServiceOptions);
+    listHubV2Connections(): Promise<ListHubV2ConnectionsResult>;
+    createHubV2Connection(input: CreateHubV2ConnectionInput): Promise<ListHubV2ConnectionsResult>;
+    updateHubV2Connection(name: string, patch: UpdateHubV2ConnectionInput): Promise<ListHubV2ConnectionsResult>;
+    deleteHubV2Connection(name: string): Promise<ListHubV2ConnectionsResult>;
+    setDefaultHubV2Connection(name: string): Promise<ListHubV2ConnectionsResult>;
+    private readPreparedState;
+    private writePreparedState;
+    private toListResult;
+}
+export {};

package/lib/modules/agent-connections/agent-connections.service.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentConnectionsService = void 0;
+const errors_1 = require("@yinuo-ngm/errors");
+const node_path_1 = __importDefault(require("node:path"));
+const env_1 = require("../../env");
+const atomic_json_file_1 = require("./atomic-json-file");
+const token_mask_1 = require("./token-mask");
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function readString(source, ...keys) {
+    for (const key of keys) {
+        const raw = source[key];
+        if (typeof raw !== "string") {
+            continue;
+        }
+        const text = raw.trim();
+        if (text) {
+            return text;
+        }
+    }
+    return undefined;
+}
+function hasOwn(source, key) {
+    return Object.prototype.hasOwnProperty.call(source, key);
+}
+function applyTokenPatch(target, key, patchValue, hasField) {
+    if (!hasField || patchValue === undefined || patchValue === "") {
+        return;
+    }
+    if (patchValue === null) {
+        delete target[key];
+        return;
+    }
+    const token = patchValue.trim();
+    if (!token) {
+        return;
+    }
+    target[key] = token;
+}
+function normalizeProject(projectName, rawValue) {
+    const raw = asRecord(rawValue);
+    const normalized = {
+        ...raw,
+    };
+    normalized.name = readString(raw, "name") ?? projectName;
+    normalized.baseUrl = readString(raw, "baseUrl", "base_url");
+    normalized.projectKey = readString(raw, "projectKey", "project_key");
+    normalized.projectName = readString(raw, "projectName", "project_name");
+    normalized.projectToken = readString(raw, "projectToken", "project_token", "token");
+    normalized.personalToken = readString(raw, "personalToken", "personal_token");
+    normalized.source = readString(raw, "source");
+    return normalized;
+}
+class AgentConnectionsService {
+    constructor(options = {}) {
+        this.dataDir = options.dataDir ?? env_1.env.dataDir;
+        this.configPath = node_path_1.default.join(this.dataDir, "agent-connections.json");
+    }
+    async listHubV2Connections() {
+        const state = await this.readPreparedState();
+        return this.toListResult(state);
+    }
+    async createHubV2Connection(input) {
+        const state = await this.readPreparedState();
+        if (state.projects[input.name]) {
+            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.FS_ALREADY_EXISTS, `hub-v2 connection already exists: ${input.name}`);
+        }
+        const nextProject = {
+            name: input.name,
+            baseUrl: input.baseUrl,
+            projectKey: input.projectKey,
+            source: "ng-manager-ui",
+        };
+        if (input.projectName) {
+            nextProject.projectName = input.projectName;
+        }
+        if (input.projectToken && input.projectToken.trim()) {
+            nextProject.projectToken = input.projectToken.trim();
+        }
+        if (input.personalToken && input.personalToken.trim()) {
+            nextProject.personalToken = input.personalToken.trim();
+        }
+        state.projects[input.name] = nextProject;
+        const projectNames = Object.keys(state.projects);
+        if (input.isDefault === true || projectNames.length === 1 || !state.defaultProject) {
+            state.defaultProject = input.name;
+        }
+        await this.writePreparedState(state);
+        return this.toListResult(state);
+    }
+    async updateHubV2Connection(name, patch) {
+        const state = await this.readPreparedState();
+        const existed = state.projects[name];
+        if (!existed) {
+            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.NOT_FOUND, `hub-v2 connection not found: ${name}`);
+        }
+        const updated = { ...existed };
+        if (hasOwn(patch, "baseUrl") && patch.baseUrl) {
+            updated.baseUrl = patch.baseUrl;
+        }
+        if (hasOwn(patch, "projectKey") && patch.projectKey) {
+            updated.projectKey = patch.projectKey;
+        }
+        if (hasOwn(patch, "projectName")) {
+            updated.projectName = patch.projectName || undefined;
+        }
+        applyTokenPatch(updated, "projectToken", patch.projectToken, hasOwn(patch, "projectToken"));
+        applyTokenPatch(updated, "personalToken", patch.personalToken, hasOwn(patch, "personalToken"));
+        state.projects[name] = updated;
+        if (patch.isDefault === true) {
+            state.defaultProject = name;
+        }
+        await this.writePreparedState(state);
+        return this.toListResult(state);
+    }
+    async deleteHubV2Connection(name) {
+        const state = await this.readPreparedState();
+        if (!state.projects[name]) {
+            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.NOT_FOUND, `hub-v2 connection not found: ${name}`);
+        }
+        delete state.projects[name];
+        if (state.defaultProject === name) {
+            const nextDefault = Object.keys(state.projects)[0];
+            state.defaultProject = nextDefault;
+        }
+        await this.writePreparedState(state);
+        return this.toListResult(state);
+    }
+    async setDefaultHubV2Connection(name) {
+        const state = await this.readPreparedState();
+        if (!state.projects[name]) {
+            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.NOT_FOUND, `hub-v2 connection not found: ${name}`);
+        }
+        state.defaultProject = name;
+        await this.writePreparedState(state);
+        return this.toListResult(state);
+    }
+    async readPreparedState() {
+        const loaded = await (0, atomic_json_file_1.readJsonObjectIfExists)(this.configPath);
+        const root = loaded.exists
+            ? { ...loaded.value }
+            : { version: 1 };
+        const hubRaw = asRecord(root.hubV2);
+        const hubV2 = { ...hubRaw };
+        const projectsRaw = asRecord(hubRaw.projects);
+        const projects = {};
+        for (const [projectName, projectValue] of Object.entries(projectsRaw)) {
+            const normalized = normalizeProject(projectName, projectValue);
+            projects[projectName] = normalized;
+        }
+        const defaultProject = readString(hubRaw, "defaultProject", "default_project");
+        return {
+            root,
+            hubV2,
+            projects,
+            defaultProject,
+        };
+    }
+    async writePreparedState(state) {
+        const nextRoot = {
+            ...state.root,
+            version: 1,
+        };
+        const nextHub = {
+            ...state.hubV2,
+            projects: state.projects,
+        };
+        if (state.defaultProject) {
+            nextHub.defaultProject = state.defaultProject;
+        }
+        else {
+            delete nextHub.defaultProject;
+        }
+        nextRoot.hubV2 = nextHub;
+        await (0, atomic_json_file_1.writeJsonAtomic)(this.configPath, nextRoot);
+    }
+    toListResult(state) {
+        const items = Object.entries(state.projects).map(([name, project]) => {
+            const projectToken = project.projectToken;
+            const personalToken = project.personalToken;
+            return {
+                name,
+                baseUrl: project.baseUrl || "",
+                projectKey: project.projectKey || "",
+                projectName: project.projectName,
+                hasProjectToken: !!projectToken,
+                hasPersonalToken: !!personalToken,
+                projectTokenPreview: (0, token_mask_1.maskToken)(projectToken),
+                personalTokenPreview: (0, token_mask_1.maskToken)(personalToken),
+                isDefault: state.defaultProject === name,
+                source: project.source,
+            };
+        });
+        return {
+            items,
+            defaultProject: state.defaultProject,
+            configPath: this.configPath,
+        };
+    }
+}
+exports.AgentConnectionsService = AgentConnectionsService;

package/lib/modules/agent-connections/agent-connections.types.d.ts

@@ -0,0 +1,57 @@
+export type HubV2ProjectRecord = {
+    name?: string;
+    baseUrl?: string;
+    projectKey?: string;
+    projectName?: string;
+    projectToken?: string;
+    personalToken?: string;
+    source?: string;
+    [key: string]: unknown;
+};
+export type HubV2Record = {
+    defaultProject?: string;
+    projects?: Record<string, HubV2ProjectRecord>;
+    [key: string]: unknown;
+};
+export type AgentConnectionsRootRecord = {
+    version?: number;
+    hubV2?: HubV2Record;
+    [key: string]: unknown;
+};
+export type HubV2ConnectionListItem = {
+    name: string;
+    baseUrl: string;
+    projectKey: string;
+    projectName?: string;
+    hasProjectToken: boolean;
+    hasPersonalToken: boolean;
+    projectTokenPreview?: string;
+    personalTokenPreview?: string;
+    isDefault: boolean;
+    source?: string;
+};
+export type ListHubV2ConnectionsResult = {
+    items: HubV2ConnectionListItem[];
+    defaultProject?: string;
+    configPath: string;
+};
+export type CreateHubV2ConnectionInput = {
+    name: string;
+    baseUrl: string;
+    projectKey: string;
+    projectName?: string;
+    projectToken?: string | null;
+    personalToken?: string | null;
+    isDefault?: boolean;
+};
+export type UpdateHubV2ConnectionInput = {
+    baseUrl?: string;
+    projectKey?: string;
+    projectName?: string;
+    projectToken?: string | null;
+    personalToken?: string | null;
+    isDefault?: boolean;
+};
+export type AgentConnectionsRoutesOptions = {
+    dataDir?: string;
+};

package/lib/modules/agent-connections/agent-connections.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/modules/agent-connections/atomic-json-file.d.ts

@@ -0,0 +1,8 @@
+import type { AgentConnectionsRootRecord } from "./agent-connections.types";
+type ReadJsonResult = {
+    exists: boolean;
+    value?: AgentConnectionsRootRecord;
+};
+export declare function readJsonObjectIfExists(filePath: string): Promise<ReadJsonResult>;
+export declare function writeJsonAtomic(filePath: string, value: AgentConnectionsRootRecord): Promise<void>;
+export {};

package/lib/modules/agent-connections/atomic-json-file.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonObjectIfExists = readJsonObjectIfExists;
+exports.writeJsonAtomic = writeJsonAtomic;
+const errors_1 = require("@yinuo-ngm/errors");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+async function readJsonObjectIfExists(filePath) {
+    try {
+        await (0, promises_1.access)(filePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { exists: false };
+        }
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.STORAGE_IO_ERROR, "failed to access agent connections config", { filePath, cause: error instanceof Error ? error.message : String(error) });
+    }
+    const text = await (0, promises_1.readFile)(filePath, "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_JSON, "agent connections config JSON parse failed", { filePath, cause: error instanceof Error ? error.message : String(error) });
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_JSON, "agent connections config must be a JSON object", { filePath });
+    }
+    return {
+        exists: true,
+        value: parsed,
+    };
+}
+async function writeJsonAtomic(filePath, value) {
+    const dir = node_path_1.default.dirname(filePath);
+    await (0, promises_1.mkdir)(dir, { recursive: true });
+    const tmpPath = `${filePath}.tmp`;
+    const content = `${JSON.stringify(value, null, 2)}\n`;
+    await (0, promises_1.writeFile)(tmpPath, content, { encoding: "utf8", mode: 0o600 });
+    await (0, promises_1.rename)(tmpPath, filePath);
+}

package/lib/modules/agent-connections/token-mask.d.ts

@@ -0,0 +1 @@
+export declare function maskToken(token?: string | null): string | undefined;

package/lib/modules/agent-connections/token-mask.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maskToken = maskToken;
+function maskToken(token) {
+    if (!token) {
+        return undefined;
+    }
+    if (token.length <= 8) {
+        return "****";
+    }
+    return `${token.slice(0, 4)}****${token.slice(-4)}`;
+}

package/lib/routes/agent-connections.routes.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+import type { AgentConnectionsRoutesOptions } from "../modules/agent-connections/agent-connections.types";
+export default function agentConnectionsRoutes(fastify: FastifyInstance, opts: AgentConnectionsRoutesOptions): Promise<void>;

package/lib/routes/agent-connections.routes.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = agentConnectionsRoutes;
+const agent_connections_schema_1 = require("../modules/agent-connections/agent-connections.schema");
+const agent_connections_service_1 = require("../modules/agent-connections/agent-connections.service");
+async function agentConnectionsRoutes(fastify, opts) {
+    const service = new agent_connections_service_1.AgentConnectionsService({ dataDir: opts?.dataDir });
+    fastify.get("/hub-v2", async () => {
+        return service.listHubV2Connections();
+    });
+    fastify.post("/hub-v2", async (req) => {
+        const input = (0, agent_connections_schema_1.parseCreateHubV2ConnectionInput)(req.body);
+        return service.createHubV2Connection(input);
+    });
+    fastify.put("/hub-v2/:name", async (req) => {
+        const name = (0, agent_connections_schema_1.parseHubV2NameParam)(req.params?.name);
+        const patch = (0, agent_connections_schema_1.parseUpdateHubV2ConnectionInput)(req.body);
+        return service.updateHubV2Connection(name, patch);
+    });
+    fastify.delete("/hub-v2/:name", async (req) => {
+        const name = (0, agent_connections_schema_1.parseHubV2NameParam)(req.params?.name);
+        return service.deleteHubV2Connection(name);
+    });
+    fastify.post("/hub-v2/:name/set-default", async (req) => {
+        const name = (0, agent_connections_schema_1.parseHubV2NameParam)(req.params?.name);
+        return service.setDefaultHubV2Connection(name);
+    });
+}

package/lib/routes/index.js

@@ -21,6 +21,7 @@ const static_files_routes_1 = __importDefault(require("./static-files.routes"));
 const hub_routes_1 = __importDefault(require("./hub.routes"));
 const node_runtime_routes_1 = __importDefault(require("./node-runtime.routes"));
 const node_version_routes_1 = __importDefault(require("./node-version.routes"));
+const agent_connections_routes_1 = __importDefault(require("./agent-connections.routes"));
 async function routes(fastify) {
     await fastify.register(system_routes_1.default);
     await fastify.register(task_routes_1.default, { prefix: '/api/tasks' });
@@ -44,4 +45,5 @@ async function routes(fastify) {
     await fastify.register(nginx_routes_1.nginxRoutes, { prefix: '/api/nginx' });
     await fastify.register(node_version_routes_1.default, { prefix: '/api/node-version' });
     await fastify.register(node_runtime_routes_1.default, { prefix: '/api/node-runtimes' });
+    await fastify.register(agent_connections_routes_1.default, { prefix: '/api/agent-connections' });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yinuo-ngm/server",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "a server package for Yinuo NG Manager",
   "author": "ZhangJing <892295834@qq.com>",
   "license": "ISC",
@@ -23,16 +23,17 @@
   "scripts": {
     "dev": "tsx watch src/index.ts",
     "build": "tsc -p tsconfig.json",
-    "start": "node lib/index.js"
+    "start": "node lib/index.js",
+    "test": "node --import tsx --test test"
   },
   "dependencies": {
     "@fastify/static": "^9.0.0",
     "@fastify/websocket": "^11.2.0",
-    "@yinuo-ngm/api": "^0.1.8",
-    "@yinuo-ngm/core": "^0.1.14",
+    "@yinuo-ngm/api": "^0.1.9",
+    "@yinuo-ngm/core": "^0.1.15",
     "@yinuo-ngm/errors": "^1.0.2",
     "@yinuo-ngm/nginx": "^0.1.4",
-    "@yinuo-ngm/protocol": "^0.1.3",
+    "@yinuo-ngm/protocol": "^0.1.4",
     "fastify": "^5.6.2",
     "fastify-plugin": "^5.1.0",
     "launch-editor": "^2.12.0",
@@ -43,5 +44,5 @@
     "@types/mime-types": "^3.0.1",
     "tsx": "^4.21.0"
   },
-  "gitHead": "f64135f6db80de6928bc0b83c29c26e408e9fcfb"
+  "gitHead": "425cb641977ad61c5f535a068f736b8970f79086"
 }

package/www/3rdpartylicenses.txt

@@ -1,4 +1,9 @@
 
+--------------------------------------------------------------------------------
+Package: ng-zorro-antd
+License: "MIT"
+
+
 --------------------------------------------------------------------------------
 Package: dayjs
 License: "MIT"
@@ -25,11 +30,6 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
---------------------------------------------------------------------------------
-Package: ng-zorro-antd
-License: "MIT"
-
-
 --------------------------------------------------------------------------------
 Package: @angular/common
 License: "MIT"