@modusoperandi/licit-import-utils 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Modus Operandi Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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/capco.util.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license MIT
+ * @copyright Copyright 2026 Modus Operandi Inc. All Rights Reserved.
+ */
+export interface Capco {
+    portionMarking?: string;
+    ism: ISM;
+}
+interface ISM {
+    system: string;
+    classification: string;
+    joint?: boolean;
+    ownerProducer?: string[];
+    atomicEnergyMarkings?: string[];
+    declassExceptions?: string[];
+    displayOnlyTo?: string[];
+    disseminationControls?: string[];
+    fgiSourceOpen?: string[];
+    fgiSourceProtected?: string[];
+    nonICMarkings?: string[];
+    nonUSControls?: string[];
+    releasableTo?: string[];
+    sciControls?: string[];
+}
+export interface UpdatedCapco {
+    containsCapco: boolean;
+    capco: Capco;
+    updatedTextContent: string;
+}
+export declare function updateCapcoFromContent(element: Element): UpdatedCapco | undefined;
+export declare function getShortCapcoString(capcoName: string): string;
+export declare function getCapcoNames(): string[];
+export declare function getCapcoNameFromShortString(capcoShort: string): string | undefined;
+export declare function getCapcoObject(capcoString: string): Capco;
+export declare function getCapcoFromNode(node: HTMLElement): string | null | undefined;
+export declare function safeCapcoParse(capco: unknown, fallback?: Capco): Capco;
+export declare function removeCapcoTextFromNode(node: Node): void;
+export {};

package/capco.util.js

@@ -0,0 +1,195 @@
+/**
+ * @license MIT
+ * @copyright Copyright 2026 Modus Operandi Inc. All Rights Reserved.
+ */
+// System Capcos list.
+const systemCapcos = ['TBD', 'U', 'C', 'S', 'TS', 'CUI', 'FOUO'];
+const capcoMap = {
+    'TO BE DETERMINED': 'TBD',
+    UNCLASSIFIED: 'U',
+    CONFIDENTIAL: 'C',
+    SECRET: 'S',
+    'TOP SECRET': 'TS',
+    'CONTROLLED UNCLASSIFIED INFORMATION': 'CUI',
+    'FOR OFFICIAL USE ONLY': 'FOUO',
+};
+const UNCLASSIFIED = 'U';
+export function updateCapcoFromContent(element) {
+    const capco = {
+        ism: {
+            classification: UNCLASSIFIED,
+            system: 'USA',
+            ownerProducer: [],
+            sciControls: [],
+            atomicEnergyMarkings: [],
+            disseminationControls: [],
+        },
+        portionMarking: 'U',
+    };
+    const textContent = element.textContent?.trimStart();
+    const updatedTextContent = textContent;
+    // Handle various CAPCO combinations
+    if (textContent) {
+        const upperText = textContent.toUpperCase();
+        // Check for (U) or (CUI) only - remove text
+        const simpleResult = handleUAndCuiCapcos(textContent, upperText, capco);
+        if (simpleResult) {
+            return simpleResult;
+        }
+        // Check if starts with ( and contains //
+        const doubleSlashResult = handleCapcoCombinations(upperText, updatedTextContent, capco);
+        if (doubleSlashResult) {
+            return doubleSlashResult;
+        }
+        // Check for full form without // - exact match with capcoMap values
+        const fullFormResult = handleFullFormCapco(upperText, updatedTextContent, capco);
+        if (fullFormResult) {
+            return fullFormResult;
+        }
+    }
+}
+// Handle (U) and (CUI) CAPCOs
+function handleUAndCuiCapcos(textContent, upperText, capco) {
+    if (upperText.startsWith('(U)') || upperText.startsWith('(CUI)')) {
+        const isU = upperText.startsWith('(U)');
+        const marker = isU ? '(U)' : '(CUI)';
+        const portionMark = isU ? 'U' : 'CUI';
+        capco.ism.classification = UNCLASSIFIED;
+        capco.portionMarking = portionMark;
+        // Remove the CAPCO text
+        const updatedTextContent = textContent.slice(marker.length).trimStart();
+        return { containsCapco: true, capco, updatedTextContent };
+    }
+    return null;
+}
+// Handle CAPCO combinations with //
+function handleCapcoCombinations(upperText, updatedTextContent, capco) {
+    if (upperText.startsWith('(') && upperText.includes('//')) {
+        const closingParenIndex = upperText.indexOf(')');
+        if (closingParenIndex > 0) {
+            const insideBracket = upperText.substring(1, closingParenIndex);
+            // Check if it starts with any systemCapco letter followed by //
+            for (const systemCapco of systemCapcos) {
+                if (insideBracket.startsWith(`${systemCapco}//`)) {
+                    capco.ism.classification = UNCLASSIFIED;
+                    capco.portionMarking = 'TBD';
+                    // Keep the original text as is
+                    return { containsCapco: true, capco, updatedTextContent };
+                }
+            }
+            // Check if it starts with any capcoMap full form followed by //
+            const capcoMapResult = checkCapcoMap(insideBracket, capco, updatedTextContent);
+            if (capcoMapResult) {
+                return capcoMapResult;
+            }
+        }
+    }
+    return null;
+}
+// Check capcoMap full form with //
+function checkCapcoMap(insideBracket, capco, updatedTextContent) {
+    for (const [fullForm] of Object.entries(capcoMap)) {
+        if (insideBracket.startsWith(`${fullForm}//`)) {
+            capco.ism.classification = UNCLASSIFIED;
+            capco.portionMarking = 'TBD';
+            // Keep the original text as is
+            return { containsCapco: true, capco, updatedTextContent };
+        }
+    }
+    return null;
+}
+// Full form CAPCO without //
+function handleFullFormCapco(upperText, updatedTextContent, capco) {
+    if (upperText.startsWith('(')) {
+        const closingParenIndex = upperText.indexOf(')');
+        if (closingParenIndex > 0) {
+            const insideBracket = upperText.substring(1, closingParenIndex).trim();
+            // Check if it exactly matches any capcoMap full form
+            for (const [fullForm] of Object.entries(capcoMap)) {
+                if (insideBracket === fullForm) {
+                    capco.ism.classification = UNCLASSIFIED;
+                    capco.portionMarking = 'TBD';
+                    // Keep the original text as is
+                    return { containsCapco: true, capco, updatedTextContent };
+                }
+            }
+        }
+    }
+    return null;
+}
+//Generic function to return capco string for corresponding capco name
+export function getShortCapcoString(capcoName) {
+    return capcoMap[capcoName] || 'U';
+}
+//Get capco Names
+export function getCapcoNames() {
+    return Object.keys(capcoMap);
+}
+//Get Capco Name from short string. Eg: 'U' -> 'UNCLASSIFIED'
+export function getCapcoNameFromShortString(capcoShort) {
+    const name = Object.entries(capcoMap).find(([_, value]) => value === capcoShort);
+    return name?.[0];
+}
+//Generic function to convert capco string to capco object
+export function getCapcoObject(capcoString) {
+    const capco = {
+        ism: {
+            classification: UNCLASSIFIED,
+            system: 'USA',
+            ownerProducer: [],
+            sciControls: [],
+            atomicEnergyMarkings: [],
+            disseminationControls: [],
+        },
+        portionMarking: 'U',
+    };
+    if (capcoString && systemCapcos.includes(capcoString)) {
+        capco.ism.classification = capcoString;
+        capco.portionMarking = capcoString;
+    }
+    return capco;
+}
+export function getCapcoFromNode(node) {
+    return (node?.getAttribute('capco') ??
+        node?.querySelector('span')?.getAttribute('capco'));
+}
+export function safeCapcoParse(capco, fallback) {
+    const defaultFallBack = {
+        ism: undefined,
+        portionMarking: 'error',
+    };
+    fallback = fallback ?? defaultFallBack;
+    if (typeof capco === 'string') {
+        try {
+            return JSON.parse(capco);
+        }
+        catch (e) {
+            console.warn('could not parse capco text: ' + capco, e);
+        }
+    }
+    if (capco && typeof capco === 'object') {
+        return capco;
+    }
+    return fallback;
+}
+export function removeCapcoTextFromNode(node) {
+    for (const child of Array.from(node.childNodes)) {
+        if (child.nodeType === Node.TEXT_NODE) {
+            let text = child.textContent ?? '';
+            for (const systemCapco of systemCapcos) {
+                const marker = `(${systemCapco.toUpperCase()})`;
+                // check only at the start
+                if (text.trimStart().toUpperCase().startsWith(marker)) {
+                    // remove only the first occurrence at the beginning
+                    text = text.trimStart().substring(marker.length).trimStart();
+                    child.textContent = text;
+                    break; // no need to check other markers
+                }
+            }
+        }
+        else if (child.hasChildNodes()) {
+            // recurse into nested elements
+            removeCapcoTextFromNode(child);
+        }
+    }
+}

package/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license MIT
+ * @copyright Copyright 2026 Modus Operandi Inc. All Rights Reserved.
+ */
+export * from './types';
+export * from './licit-transform';
+export * from './transform.docx';
+export * from './transform.zip';

package/index.js

@@ -0,0 +1,8 @@
+/**
+ * @license MIT
+ * @copyright Copyright 2026 Modus Operandi Inc. All Rights Reserved.
+ */
+export * from './types';
+export * from './licit-transform';
+export * from './transform.docx';
+export * from './transform.zip';