@vltpkg/query 1.0.0-rc.22 → 1.0.0-rc.24

package/dist/pseudo/hostname.js

@@ -0,0 +1,138 @@
+import { splitDepID } from '@vltpkg/dep-id/browser';
+import { getOptions, gitHostWebsites } from '@vltpkg/spec/browser';
+import { asPostcssNodeWithChildren } from '@vltpkg/dss-parser';
+import { error } from '@vltpkg/error-cause';
+import { removeDanglingEdges, removeNode } from "./helpers.js";
+import { parseInternals } from "./spec.js";
+/**
+ * Given a named git host (e.g. "github"), resolve its hostname
+ * by looking up `gitHostWebsites` (e.g. "github.com"), or
+ * falling back to the `git-hosts` template URL.
+ */
+const resolveGitHostname = (namedHost, gitHosts) => {
+    // Check gitHostWebsites first (e.g. github -> github.com)
+    const website = gitHostWebsites[namedHost];
+    if (website) {
+        try {
+            return new URL(website).hostname;
+            /* c8 ignore next */
+        }
+        catch { }
+    }
+    // Fall back to parsing the git-hosts template URL
+    const template = gitHosts[namedHost];
+    if (template) {
+        try {
+            // Templates look like 'git+ssh://git@github.com:$1/$2.git'
+            // Replace colons after the host with / for URL parsing
+            const normalized = template
+                .replace(/^git\+/, '')
+                .replace(/:(\$)/, '/$1');
+            return new URL(normalized).hostname;
+            /* c8 ignore next */
+        }
+        catch { }
+    }
+    /* c8 ignore next */
+    return undefined;
+};
+/**
+ * Resolve the hostname for a git remote string.
+ * Named hosts: "github:user/repo" -> extract "github" and look up.
+ * Full URLs: "git+ssh://git@example.com/repo.git" -> parse URL.
+ */
+const getGitHostname = (gitRemote, gitHosts) => {
+    // Check if it's a named git host like "github:user/repo"
+    const colonIdx = gitRemote.indexOf(':');
+    if (colonIdx > 0) {
+        const possibleHost = gitRemote.slice(0, colonIdx);
+        // If this is a known named git host, resolve it
+        if (possibleHost in gitHosts) {
+            return resolveGitHostname(possibleHost, gitHosts);
+        }
+        // Could be a protocol URL like git+ssh://...
+        try {
+            const normalized = gitRemote
+                .replace(/^git\+/, '')
+                .replace(/^ssh:\/\/([^@]+@)?([^:/]+)[:/]/, 'ssh://$1$2/');
+            return new URL(normalized).hostname;
+            /* c8 ignore next */
+        }
+        catch { }
+    }
+    /* c8 ignore start - git remotes always contain a colon */
+    // Try parsing as a plain URL
+    try {
+        return new URL(gitRemote).hostname;
+    }
+    catch { }
+    return undefined;
+    /* c8 ignore stop */
+};
+/**
+ * :hostname(str) Pseudo-Selector, matches only nodes whose
+ * upstream hostname matches the provided domain string.
+ *
+ * Examples:
+ * - :hostname("registry.npmjs.org") — default npm registry deps
+ * - :hostname("github.com") — github git deps
+ * - :hostname("example.com") — custom registry deps
+ */
+export const hostname = async (state) => {
+    let internals;
+    try {
+        internals = parseInternals(asPostcssNodeWithChildren(state.current).nodes);
+    }
+    catch (err) {
+        throw error('Failed to parse :hostname selector', {
+            cause: err,
+        });
+    }
+    const targetHostname = internals.specValue;
+    for (const node of state.partial.nodes) {
+        const tuple = splitDepID(node.id);
+        const type = tuple[0];
+        let nodeHostname;
+        switch (type) {
+            case 'registry': {
+                const registryName = tuple[1];
+                const options = getOptions(node.options);
+                // Look up the registry URL from registries map
+                const registryUrl = options.registries[registryName] ?? options.registry;
+                if (registryUrl) {
+                    try {
+                        nodeHostname = new URL(registryUrl).hostname;
+                        /* c8 ignore next */
+                    }
+                    catch { }
+                }
+                break;
+            }
+            case 'git': {
+                const gitRemote = tuple[1];
+                const options = getOptions(node.options);
+                nodeHostname = getGitHostname(gitRemote, options['git-hosts']);
+                break;
+            }
+            case 'remote': {
+                const url = tuple[1];
+                try {
+                    nodeHostname = new URL(url).hostname;
+                    /* c8 ignore next */
+                }
+                catch { }
+                break;
+            }
+            // file and workspace deps are local — no hostname
+            default: {
+                nodeHostname = undefined;
+                break;
+            }
+        }
+        if (nodeHostname !== targetHostname) {
+            removeNode(state, node);
+        }
+    }
+    removeDanglingEdges(state);
+    return state;
+};

package/dist/pseudo/license.d.ts

@@ -0,0 +1,12 @@
+import type { ParserState } from '../types.ts';
+import type { PostcssNode } from '@vltpkg/dss-parser';
+export type LicenseKinds = 'unlicensed' | 'misc' | 'restricted' | 'ambiguous' | 'copyleft' | 'unknown' | 'none' | 'exception' | undefined;
+export type LicenseAlertTypes = 'explicitlyUnlicensedItem' | 'miscLicenseIssues' | 'nonpermissiveLicense' | 'ambiguousClassifier' | 'copyleftLicense' | 'unidentifiedLicense' | 'noLicenseFound' | 'licenseException' | undefined;
+export declare const isLicenseKind: (value?: string) => value is LicenseKinds;
+export declare const asLicenseKind: (value?: string) => LicenseKinds;
+export declare const parseInternals: (nodes: PostcssNode[]) => {
+    kind: LicenseKinds;
+};
+export declare const license: (state: ParserState) => Promise<ParserState & {
+    securityArchive: NonNullable<ParserState["securityArchive"]>;
+}>;

package/dist/pseudo/license.js

@@ -0,0 +1,74 @@
+import { error } from '@vltpkg/error-cause';
+import { asError } from '@vltpkg/types';
+import { asPostcssNodeWithChildren, asStringNode, asTagNode, isStringNode, isTagNode, } from '@vltpkg/dss-parser';
+import { assertSecurityArchive, removeDanglingEdges, removeNode, removeQuotes, } from "./helpers.js";
+const kindsMap = new Map([
+    ['unlicensed', 'explicitlyUnlicensedItem'],
+    ['misc', 'miscLicenseIssues'],
+    ['restricted', 'nonpermissiveLicense'],
+    ['ambiguous', 'ambiguousClassifier'],
+    ['copyleft', 'copyleftLicense'],
+    ['unknown', 'unidentifiedLicense'],
+    ['none', 'noLicenseFound'],
+    ['exception', 'licenseException'],
+    [undefined, undefined],
+]);
+const kinds = new Set(kindsMap.keys());
+export const isLicenseKind = (value) => kinds.has(value);
+export const asLicenseKind = (value) => {
+    if (!isLicenseKind(value)) {
+        throw error('Expected a valid license kind', {
+            found: value,
+            validOptions: Array.from(kinds),
+        });
+    }
+    return value;
+};
+export const parseInternals = (nodes) => {
+    let kind;
+    if (isStringNode(asPostcssNodeWithChildren(nodes[0]).nodes[0])) {
+        kind = asLicenseKind(removeQuotes(asStringNode(asPostcssNodeWithChildren(nodes[0]).nodes[0])
+            .value));
+    }
+    else if (isTagNode(asPostcssNodeWithChildren(nodes[0]).nodes[0])) {
+        kind = asLicenseKind(asTagNode(asPostcssNodeWithChildren(nodes[0]).nodes[0]).value);
+    }
+    return { kind };
+};
+export const license = async (state) => {
+    assertSecurityArchive(state, 'license');
+    let internals;
+    try {
+        internals = parseInternals(asPostcssNodeWithChildren(state.current).nodes);
+    }
+    catch (err) {
+        if (asError(err).message === 'Expected a query node') {
+            // No parameters provided - pseudo state form: match ANY license defined (not 'none')
+            for (const node of state.partial.nodes) {
+                const report = state.securityArchive.get(node.id);
+                // Exclude if no report or if it has 'noLicenseFound' alert
+                const exclude = !report?.alerts ||
+                    report.alerts.some(alert => alert.type === 'noLicenseFound');
+                if (exclude) {
+                    removeNode(state, node);
+                }
+            }
+            removeDanglingEdges(state);
+            return state;
+        }
+        else {
+            throw error('Failed to parse :license selector', { cause: err });
+        }
+    }
+    const { kind } = internals;
+    const alertName = kindsMap.get(kind);
+    for (const node of state.partial.nodes) {
+        const report = state.securityArchive.get(node.id);
+        const exclude = !report?.alerts.some(alert => alert.type === alertName);
+        if (exclude) {
+            removeNode(state, node);
+        }
+    }
+    removeDanglingEdges(state);
+    return state;
+};

package/dist/pseudo/link.d.ts

@@ -0,0 +1,8 @@
+import type { ParserState } from '../types.ts';
+/**
+ * :link Pseudo-Selector, matches only nodes that are file links.
+ *
+ * It filters out any node that is not of type 'file' or nodes of 'file'
+ * type that ends with 'tar.gz' since these are local tarballs.
+ */
+export declare const link: (state: ParserState) => Promise<ParserState>;

package/dist/pseudo/link.js

@@ -0,0 +1,24 @@
+import { splitDepID } from '@vltpkg/dep-id/browser';
+import { removeNode } from "./helpers.js";
+/**
+ * :link Pseudo-Selector, matches only nodes that are file links.
+ *
+ * It filters out any node that is not of type 'file' or nodes of 'file'
+ * type that ends with 'tar.gz' since these are local tarballs.
+ */
+export const link = async (state) => {
+    for (const node of state.partial.nodes) {
+        const [type, path] = splitDepID(node.id);
+        if (type !== 'file' || path.endsWith('tar.gz') || path === '.') {
+            removeNode(state, node);
+        }
+    }
+    for (const edge of state.partial.edges) {
+        if (!edge.spec.file ||
+            edge.spec.file.endsWith('tar.gz') ||
+            edge.spec.file === '.') {
+            state.partial.edges.delete(edge);
+        }
+    }
+    return state;
+};

package/dist/pseudo/malware.d.ts

@@ -0,0 +1,23 @@
+import type { ParserState } from '../types.ts';
+import type { PostcssNode } from '@vltpkg/dss-parser';
+export type MalwareKinds = '0' | '1' | '2' | '3' | 'critical' | 'high' | 'medium' | 'low' | undefined;
+export type MalwareAlertTypes = 'malware' | 'gptMalware' | 'gptSecurity' | 'gptAnomaly' | undefined;
+export type MalwareComparator = '>' | '<' | '>=' | '<=' | undefined;
+export declare const isMalwareKind: (value?: string) => value is MalwareKinds;
+export declare const asMalwareKind: (value?: string) => MalwareKinds;
+export declare const parseInternals: (nodes: PostcssNode[]) => {
+    kind: MalwareKinds;
+    comparator: MalwareComparator;
+};
+/**
+ * :malware Pseudo-Selector, matches nodes with malware alerts.
+ *
+ * Usage:
+ * - :malware - matches malware with severity >= medium (critical, high, medium but not low)
+ * - :malware(critical) - matches specific malware kind
+ * - :malware(>1) - matches malware with severity greater than 1
+ * - :malware(">=medium") - matches malware with severity >= medium
+ */
+export declare const malware: (state: ParserState) => Promise<ParserState & {
+    securityArchive: NonNullable<ParserState["securityArchive"]>;
+}>;

package/dist/pseudo/malware.js

@@ -0,0 +1,186 @@
+import { error } from '@vltpkg/error-cause';
+import { asPostcssNodeWithChildren, asStringNode, asTagNode, isStringNode, isTagNode, } from '@vltpkg/dss-parser';
+import { assertSecurityArchive, removeDanglingEdges, removeNode, removeQuotes, } from "./helpers.js";
+const kindsMap = new Map([
+    ['critical', 'malware'],
+    ['high', 'gptMalware'],
+    ['medium', 'gptSecurity'],
+    ['low', 'gptAnomaly'],
+    ['0', 'malware'],
+    ['1', 'gptMalware'],
+    ['2', 'gptSecurity'],
+    ['3', 'gptAnomaly'],
+]);
+// Map numerical values to their respective kinds for comparison operations
+const kindLevelMap = new Map([
+    ['critical', 0],
+    ['high', 1],
+    ['medium', 2],
+    ['low', 3],
+    ['0', 0],
+    ['1', 1],
+    ['2', 2],
+    ['3', 3],
+]);
+const kinds = new Set(kindsMap.keys());
+export const isMalwareKind = (value) => kinds.has(value);
+export const asMalwareKind = (value) => {
+    if (!isMalwareKind(value)) {
+        throw error('Expected a valid malware kind', {
+            found: value,
+            validOptions: Array.from(kinds),
+        });
+    }
+    return value;
+};
+export const parseInternals = (nodes) => {
+    // Handle case where no parameters are provided (parameterless :malware)
+    if (!nodes[0]) {
+        return { kind: undefined, comparator: undefined };
+    }
+    const selectorNode = asPostcssNodeWithChildren(nodes[0]);
+    if (!selectorNode.nodes[0]) {
+        return { kind: undefined, comparator: undefined };
+    }
+    let kindValue = '';
+    let comparator = undefined;
+    let kind;
+    // Parse the parameter (kind with optional comparator)
+    if (isStringNode(selectorNode.nodes[0])) {
+        kindValue = removeQuotes(asStringNode(selectorNode.nodes[0]).value);
+    }
+    else if (isTagNode(selectorNode.nodes[0])) {
+        kindValue = asTagNode(selectorNode.nodes[0]).value;
+    }
+    // Extract comparator if present
+    if (kindValue.startsWith('>=')) {
+        comparator = '>=';
+        kindValue = kindValue.substring(2);
+    }
+    else if (kindValue.startsWith('<=')) {
+        comparator = '<=';
+        kindValue = kindValue.substring(2);
+    }
+    else if (kindValue.startsWith('>')) {
+        comparator = '>';
+        kindValue = kindValue.substring(1);
+    }
+    else if (kindValue.startsWith('<')) {
+        comparator = '<';
+        kindValue = kindValue.substring(1);
+    }
+    // Validate the kind without comparator
+    if (!comparator) {
+        kind = asMalwareKind(kindValue);
+    }
+    else {
+        // For comparisons, just make sure it's a valid numeric value or a valid kind
+        if (isMalwareKind(kindValue)) {
+            kind = kindValue;
+        }
+        else {
+            throw error('Expected a valid malware kind or number between 0-3', {
+                found: kindValue,
+            });
+        }
+    }
+    return { kind, comparator };
+};
+/**
+ * :malware Pseudo-Selector, matches nodes with malware alerts.
+ *
+ * Usage:
+ * - :malware - matches malware with severity >= medium (critical, high, medium but not low)
+ * - :malware(critical) - matches specific malware kind
+ * - :malware(>1) - matches malware with severity greater than 1
+ * - :malware(">=medium") - matches malware with severity >= medium
+ */
+export const malware = async (state) => {
+    assertSecurityArchive(state, 'malware');
+    let internals;
+    try {
+        internals = parseInternals(asPostcssNodeWithChildren(state.current).nodes);
+    }
+    catch (err) {
+        throw error('Failed to parse :malware selector', { cause: err });
+    }
+    const { kind, comparator } = internals;
+    const alertName = comparator ? undefined : kindsMap.get(kind);
+    for (const node of state.partial.nodes) {
+        const report = state.securityArchive.get(node.id);
+        // Always exclude nodes that don't have security data or alerts
+        if (!report?.alerts || report.alerts.length === 0) {
+            removeNode(state, node);
+        }
+    }
+    for (const node of state.partial.nodes) {
+        const report = state.securityArchive.get(node.id);
+        let exclude = true;
+        if (report) {
+            if (kind === undefined && comparator === undefined) {
+                // Parameterless :malware - match malware alerts with severity >= medium (exclude low/gptAnomaly)
+                exclude = !report.alerts.some(alert => alert.type === 'malware' ||
+                    alert.type === 'gptMalware' ||
+                    alert.type === 'gptSecurity');
+            }
+            else if (comparator) {
+                // retrieve the value to compare against
+                const kindLevel = kindLevelMap.get(kind);
+                // the kindLevel value has already been validated at this point
+                // and thus can never return an undefined/falsy value but ts doesn't
+                // know about that, so we have the extra check here
+                /* c8 ignore next - impossible */
+                if (kindLevel == null)
+                    break;
+                // Check each alert to find any that match our comparison criteria
+                for (const alert of report.alerts) {
+                    // Get the numerical value of the alert type
+                    const alertType = alert.type;
+                    // retrieve a key to the current alert level to be compared against
+                    const currentAlertLevelKey = [...kindsMap.entries()].find(([_, alertValue]) => alertValue === alertType)?.[0];
+                    // perform the comparison based on the user-provided kindLevel
+                    if (currentAlertLevelKey) {
+                        const currentAlertLevel = kindLevelMap.get(currentAlertLevelKey);
+                        /* c8 ignore next - impossible but ts doesn't know */
+                        if (currentAlertLevel == null)
+                            continue;
+                        switch (comparator) {
+                            case '>':
+                                if (currentAlertLevel > kindLevel) {
+                                    exclude = false;
+                                }
+                                break;
+                            case '<':
+                                if (currentAlertLevel < kindLevel) {
+                                    exclude = false;
+                                }
+                                break;
+                            case '>=':
+                                if (currentAlertLevel >= kindLevel) {
+                                    exclude = false;
+                                }
+                                break;
+                            case '<=':
+                                if (currentAlertLevel <= kindLevel) {
+                                    exclude = false;
+                                }
+                                break;
+                        }
+                        // If we've found a match, no need to check other alerts
+                        if (!exclude)
+                            break;
+                    }
+                }
+            }
+            else {
+                // Original exact match behavior
+                exclude = !report.alerts.some(alert => alert.type === alertName);
+            }
+        }
+        if (exclude) {
+            removeNode(state, node);
+        }
+    }
+    removeDanglingEdges(state);
+    return state;
+};

package/dist/pseudo/minified.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Filters out any node that does not have a **minifiedFile** report alert.
+ */
+export declare const minified: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
+    securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
+}>;

package/dist/pseudo/minified.js

@@ -0,0 +1,5 @@
+import { createSecuritySelectorFilter } from "./helpers.js";
+/**
+ * Filters out any node that does not have a **minifiedFile** report alert.
+ */
+export const minified = createSecuritySelectorFilter('minified', 'minifiedFile');

package/dist/pseudo/missing.d.ts

@@ -0,0 +1,7 @@
+import type { ParserState } from '../types.ts';
+/**
+ * :missing Pseudo-Selector, matches only edges that are not linked to any node.
+ * It filters out any edges that have a 'to' property, keeping only dangling edges
+ * and clears all nodes from the result.
+ */
+export declare const missing: (state: ParserState) => Promise<ParserState>;

package/dist/pseudo/missing.js

@@ -0,0 +1,14 @@
+/**
+ * :missing Pseudo-Selector, matches only edges that are not linked to any node.
+ * It filters out any edges that have a 'to' property, keeping only dangling edges
+ * and clears all nodes from the result.
+ */
+export const missing = async (state) => {
+    for (const edge of state.partial.edges) {
+        if (edge.to) {
+            state.partial.edges.delete(edge);
+        }
+    }
+    state.partial.nodes.clear();
+    return state;
+};

package/dist/pseudo/native.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Filters out any node that does not have a **hasNativeCode** report alert.
+ */
+export declare const nativeParser: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
+    securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
+}>;

package/dist/pseudo/native.js

@@ -0,0 +1,5 @@
+import { createSecuritySelectorFilter } from "./helpers.js";
+/**
+ * Filters out any node that does not have a **hasNativeCode** report alert.
+ */
+export const nativeParser = createSecuritySelectorFilter('native', 'hasNativeCode');

package/dist/pseudo/network.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Filters out any node that does not have a **networkAccess** report alert.
+ */
+export declare const network: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
+    securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
+}>;

package/dist/pseudo/network.js

@@ -0,0 +1,5 @@
+import { createSecuritySelectorFilter } from "./helpers.js";
+/**
+ * Filters out any node that does not have a **networkAccess** report alert.
+ */
+export const network = createSecuritySelectorFilter('network', 'networkAccess');

package/dist/pseudo/obfuscated.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Filters out any node that does not have an **obfuscatedFile** report alert.
+ */
+export declare const obfuscated: (state: import("../types.ts").ParserState) => Promise<import("../types.ts").ParserState & {
+    securityArchive: NonNullable<import("../types.ts").ParserState["securityArchive"]>;
+}>;

package/dist/pseudo/obfuscated.js

@@ -0,0 +1,5 @@
+import { createSecuritySelectorFilter } from "./helpers.js";
+/**
+ * Filters out any node that does not have an **obfuscatedFile** report alert.
+ */
+export const obfuscated = createSecuritySelectorFilter('obfuscated', 'obfuscatedFile');

package/dist/pseudo/optional.d.ts

@@ -0,0 +1,5 @@
+import type { ParserState } from '../types.ts';
+/**
+ * :optional Pseudo-Selector will only match optional dependencies.
+ */
+export declare const optional: (state: ParserState) => Promise<ParserState>;

package/dist/pseudo/optional.js

@@ -0,0 +1,14 @@
+import { removeEdge, removeUnlinkedNodes } from "./helpers.js";
+/**
+ * :optional Pseudo-Selector will only match optional dependencies.
+ */
+export const optional = async (state) => {
+    // filter edges that aren't marked as optional
+    for (const edge of state.partial.edges) {
+        if (!edge.optional) {
+            removeEdge(state, edge);
+        }
+    }
+    removeUnlinkedNodes(state);
+    return state;
+};

package/dist/pseudo/outdated.d.ts

@@ -0,0 +1,53 @@
+import type { NodeLike } from '@vltpkg/types';
+import type { ParserState } from '../types.ts';
+import type { PostcssNode } from '@vltpkg/dss-parser';
+/**
+ * The possible values accepted by the :outdated() pseudo selector.
+ */
+export type OutdatedKinds = 'any' | 'major' | 'minor' | 'patch' | 'in-range' | 'out-of-range';
+/**
+ * Result of the internal parsing of the :outdated() pseudo selector.
+ */
+export type OutdatedInternals = {
+    kind: OutdatedKinds;
+};
+/**
+ * Extracts a semver type from a version string.
+ */
+export type SemverTypeExtraction = (version: string) => number | undefined;
+/**
+ * Checks if a string is a valid {@link OutdatedKinds}.
+ */
+export declare const isOutdatedKind: (value: string) => value is OutdatedKinds;
+/**
+ * Asserts that a string is a valid {@link OutdatedKinds}.
+ */
+export declare const asOutdatedKind: (value: string) => OutdatedKinds;
+/**
+ * Fetches the available versions of a package from the npm registry.
+ */
+export declare const retrieveRemoteVersions: (node: NodeLike, signal?: AbortSignal) => Promise<string[]>;
+/**
+ * Retrieves what kind of check the :outdated selector should perform.
+ */
+export declare const parseInternals: (nodes: PostcssNode[]) => OutdatedInternals;
+/**
+ * Filter nodes by queueing up for removal those that are not outdated.
+ */
+export declare const queueNode: (state: ParserState, node: NodeLike, kind: OutdatedKinds) => Promise<NodeLike | undefined>;
+/**
+ * Filters out nodes that are not outdated.
+ *
+ * The :outdated() pseudo selector supports one `type` argument,
+ * possible values are the following:
+ *
+ * - `any`: Selects all nodes that have a greater version available.
+ * - `major`: Selects all nodes that have a greater major version available.
+ * - `minor`: Selects all nodes that have a greater minor version available.
+ * - `patch`: Selects all nodes that have a greater patch version available.
+ * - `in-range`: Selects all nodes that have a parent node with a spec definition
+ *  that satisfies one of the available remote versions.
+ *  - `out-of-range`: Selects all nodes that have a parent node with a spec definition
+ *  that does not satisfy any of the available remote versions.
+ */
+export declare const outdated: (state: ParserState) => Promise<ParserState>;