@pubid/pubid 0.1.7 → 0.1.9

package/dist/flavors/ieee/artifact_tree.js

@@ -0,0 +1,36 @@
+import { normalizeShape } from "../../parg/runtime.js";
+/**
+ * The baked PARG artifact's parse shape → the builder tree. The
+ * artifact (the gem's own runtime grammar) differs from the hand
+ * mirror in three enumerable ways:
+ *
+ * - a sequence binds as a top-level Array of capture hashes — folded
+ *   into one hash (last key wins), the reference's to_builder_hash;
+ * - zero-width alternative branches bind null-valued keys; the hand
+ *   tree omits them;
+ * - `part`/`subpart` capture their separator (".18", "-10") — kept,
+ *   the builder joins code captures verbatim exactly like the
+ *   reference's extract_attributes.
+ */
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+export function artifactToBuilderTree(shape) {
+    const normalized = normalizeShape(shape);
+    const folded = Array.isArray(normalized) && normalized.length > 0 &&
+        normalized.every((n) => isObj(n))
+        ? Object.assign({}, ...normalized)
+        : normalized;
+    return convert(folded);
+}
+function convert(node) {
+    if (Array.isArray(node))
+        return node.map(convert);
+    if (!isObj(node))
+        return node;
+    const out = {};
+    for (const [k, v] of Object.entries(node)) {
+        if (v === null)
+            continue;
+        out[k] = convert(v);
+    }
+    return out;
+}

package/dist/flavors/ieee/grammar.js

@@ -32,6 +32,10 @@ function buildRules() {
     const dot = str(".");
     const slash = str("/");
     const comma = str(", ");
+    // The artifact's date tails use the bare "," literal with an optional
+    // space ("," [space]) / space), which accepts the glued "D3.0,May 2008"
+    // spellings the comma rule (", ") cannot see.
+    const commaGlued = () => str(",").then(spaceMaybe()).or(comma).or(space);
     const digit = match("[0-9]");
     const digits = digit.repeat(1, Infinity);
     const upper = match("[A-Z]");
@@ -53,10 +57,10 @@ function buildRules() {
     rule("date_standalone", () => ref(rules, "date_with_month_text")
         .or(ref(rules, "date_with_month_numeric"))
         .or(R("year_digits").as("year")));
-    rule("trailing_month_year", () => (comma.or(space)
+    rule("trailing_month_year", () => (commaGlued()
         .then(monthName().as("trailing_month"))
         .then(space)
-        .then(R("year_digits").as("trailing_year"))).or(comma.or(space)
+        .then(R("year_digits").as("trailing_year"))).or(str(",").or(space)
         .then(R("month_numeric").as("trailing_month"))
         .then(space.or(dash))
         .then(R("year_digits").as("trailing_year"))));
@@ -91,7 +95,6 @@ function buildRules() {
         .then(ref(rules, "parenthetical").maybe()));
     rule("number", () => (str("P").maybe()
         .then(upper.repeat(0, Infinity)).then(digits).then(digits.or(upper).repeat(0, Infinity))
-        .then(dash.then(digits).then(absent(R("year_digits"))).then(dash.then(digits).repeat(0, Infinity)).maybe())
         .then(lower.maybe())).as("number"));
     rule("type_word", () => str("Draft Std")
         .or(str("STD"))
@@ -102,7 +105,13 @@ function buildRules() {
         .or(match("[Nn]").then(str("o.")))
         .or(match("[Nn]").then(str("o")))
         .or(str("No")));
-    rule("part", () => (dot.or(dash)).then(match("[0-9A-Za-z]").repeat(1, Infinity).as("part")));
+    rule("part", () => (dot.or(dash)).as("part_sep")
+        .then(absent(str("REV").or(str("Rev")).or(str("rev"))
+        .then(spaceMaybe())
+        .then(match("[0-9A-Za-z]")))
+        .then(match("[0-9A-Za-z]"))
+        .repeat(1, Infinity)
+        .as("part")));
     rule("subpart", () => (dot.or(dash).or(str("_"))).then((str("REV").or(str("Rev")).maybe()
         .then(match("[0-9a-z]").repeat(1, Infinity))
         .then(dot.then(digits).maybe())).as("subpart")));
@@ -114,20 +123,26 @@ function buildRules() {
     rule("draft_version", () => absent(str("R").then(dash))
         .then(str("D").then(absent(str("IS"))).maybe())
         .then((match("[0-9]").repeat(1, 2).then(dot).then(match("[0-9]").repeat(1, 2)).then(lower.maybe())).or(dot.then(digits))
+        // The artifact's dot-led version: "." + non-year alnum/dot run
+        // (the ".D" of "/Ddraft.D=FDIS").
+        .or(dot.then(absent(R("year_digits"))).then(match("[0-9A-Za-z.]").repeat(1, Infinity)))
         .or(digits.then(str("+")).then(digits))
         .or(digits.then(dot.maybe()).then(str("e")).then(digits))
         .or(str("-").maybe()
         .then(match("[0-9A-Za-z]").repeat(1, Infinity))
         .then(str("-d").or(str("_").then(match("[0-9A-Za-z]").repeat(0, Infinity))).maybe())).as("draft_version")));
-    rule("draft_date", () => (comma.or(space).then(monthName().as("month")).then(space).then(R("year_digits").as("year"))).or(
+    rule("draft_date", () => (
+    // The canonical forced-comma render (", Feb, 2011") comma-joins
+    // the month and year, matching the joint tails.
+    commaGlued().then(monthName().as("month")).then(space.or(comma)).then(R("year_digits").as("year"))).or(
     // Space-separated bare year after the draft designator
     // ("IEEE Draft Std P14764/D1 2004, Nov 2004" - the "D1 2004" draft
     // carries its own year, with the print date still trailing).
-    space.then(R("year_digits").as("year"))).or(comma.or(space).then(R("month_numeric").as("month")).then(space.or(dash)).then(R("year_digits").as("year"))).or((spaceMaybe().then(comma).then(spaceMaybe()).or(space)).then(monthName().as("month")).then((space.then(digits.as("day")).then(comma.or(space).or(dash)).then(R("year_digits").as("year"))).or(space.then(digits.as("day")).maybe().then(comma).then(R("year_digits").as("year"))).or(comma.then(spaceMaybe()).then(R("year_digits").as("year")))
+    space.then(R("year_digits").as("year"))).or(str(",").or(space).then(R("month_numeric").as("month")).then(space.or(dash)).then(R("year_digits").as("year"))).or((spaceMaybe().then(comma).then(spaceMaybe()).or(space)).then(monthName().as("month")).then((space.then(digits.as("day")).then(comma.or(space).or(dash)).then(R("year_digits").as("year"))).or(space.then(digits.as("day")).maybe().then(comma).then(R("year_digits").as("year"))).or(comma.then(spaceMaybe()).then(R("year_digits").as("year")))
         .or(space.then(R("year_digits").as("year"))))));
-    rule("fdraft", () => (slash
+    rule("fdraft", () => (slash.or(str("_"))
         .then(literalAlternation(["FDIS", "CDV", "CD", "WD", "PWI", "NP"]))
-        .then((comma.or(space).then(monthName().as("month")).then(space).then(R("year_digits").as("year"))).or(comma.or(space).then(R("year_digits").as("year"))).maybe())
+        .then((commaGlued().then(monthName().as("month")).then(space).then(R("year_digits").as("year"))).or(comma.or(space).then(R("year_digits").as("year"))).maybe())
         .then(ref(rules, "parenthetical").maybe())).as("fdraft"));
     rule("draft", () => (ref(rules, "draft_prefix")
         .then(ref(rules, "draft_version").repeat(1, 2))
@@ -311,9 +326,21 @@ function buildRules() {
             .or(stagedOnly.as("joint_publishers").then(space).then(isoStage()).then(stdNoise()).then(space)))
             .then(str("P").as("project_marker").maybe())
             .then(digits.as("number"))
-            .then((dot.then(absent(R("year_digits"))).then(digits.as("part")))
+            .then(
+        // Digits-only parts keep their tree under any date spelling. A
+        // letter-suffixed part is the ISO print with a COLON year only
+        // (pubid#215: "8802-1AC:2018") - a dash-year letter part
+        // ("8802-1AC-2018") belongs to the later joint-IEEE rules, so
+        // the colon lookahead gates it.
+        (dot.then(absent(R("year_digits"))).then(digits.as("part")))
             .or(dash.then(str("").as("part_dash")).then(absent(R("year_digits")))
             .then(digits.as("part")))
+            .or(dot.then(absent(R("year_digits")))
+            .then(digits.then(match("[A-Za-z]").repeat(1, Infinity)).as("part"))
+            .then(str(":").present()))
+            .or(dash.then(str("").as("part_dash")).then(absent(R("year_digits")))
+            .then(digits.then(match("[A-Za-z]").repeat(1, Infinity)).as("part"))
+            .then(str(":").present()))
             .maybe())
             .then(dateClause())
             .then(
@@ -331,14 +358,27 @@ function buildRules() {
             .then(dot.then(digits.then(match("[A-Za-z]").repeat(0, 1)).as("draft_iso_iteration")).maybe()))
             .or(slash.then(str("D")).then(dashMaybe())
             .then(match("[0-9.]").repeat(1, Infinity).as("draft_version"))
-            .then(((comma.or(space)).then(monthName().as("draft_month")).then(space)
+            .then(((comma.or(space)).then(monthName().as("draft_month")).then(space.or(comma))
             .then(R("year_digits").as("draft_year"))).or(comma.then(R("year_digits").as("draft_year"))).maybe())).maybe())
             .then((slash.then(str("Amd")).then(dot.or(space).maybe())
             .then(digits.as("amd_number"))
             .then((str(":").or(dash)).then(R("year_digits").as("amd_year")).maybe())).maybe())
+            // The ISO print's dotted corrigendum tail (pubid#215):
+            // "8802-1AC:2018/Cor.1:2020(E)".
+            .then(ref(rules, "corrigendum").maybe())
             .then(ref(rules, "edition").maybe())
             .then(ref(rules, "revision_suffix").maybe())
-            .then(ref(rules, "parenthetical").maybe());
+            // The joint rule's trailing parenthetical is the NARROW one (a
+            // language/edition marker or P&V) - the reference's relationship
+            // vocabulary does not accept mis-typed narratives ("Revison of…"),
+            // so the loose catch-all would over-accept ahead of the redline.
+            .then((spaceMaybe().then(str("("))
+            .then(match("[A-Z]").then(match("[/][A-Z]").repeat(0, Infinity)).as("edition_marker"))
+            .then(str(")"))
+            .or(spaceMaybe().then(str("(P&V)")).as("parenthetical_content"))).maybe())
+            // The joint ISO-print redline is a distinct document (pubid#215):
+            // "15289:2015(E) - Redline".
+            .then(ref(rules, "redline").maybe());
     });
     // The stage-less ISO/IEC label with a colon year and the ISO/IEC
     // edition marker: "ISO/IEC 13210:1994 (E)" - the ISO/IEC portion of a
@@ -533,8 +573,34 @@ function buildRules() {
         .then(ref(rules, "nesc_month"))
         .then(space)
         .then(digit.repeat(4, 4).as("year")));
+    // Preprint is a draft STAGE of the C2 code (NESC terminology for its
+    // pre-edition drafts), not a variant: dotted is the canonical spelling
+    // (C2.2012.Preprint); dash (C2-2012-Preprint) and the catalogue's
+    // slash tail (C2-2002/Preprint) are aliases. The verbose
+    // "Preprint Proposal(s) for the YYYY Edition of ..." forms cite the
+    // same draft by its target edition year. Longest literal first —
+    // "Proposals" / "Proposal" — the choice does not retry the shorter
+    // alternative when the continuation fails.
+    rule("nesc_c2_preprint", () => ref(rules, "nesc_c2_code")
+        .then(str(".").then(digit.repeat(4, 4).as("year")).then(str("."))
+        .or(dash.then(digit.repeat(4, 4).as("year")).then(dash))
+        .or(dash.then(digit.repeat(4, 4).as("year")).then(str("/"))))
+        .then(str("Preprint").as("preprint")));
+    rule("nesc_preprint_proposal", () => str("Preprint").as("preprint")
+        .then(space)
+        .then(str("Proposals").or(str("Proposal")))
+        .then(space)
+        .then(str("for")).then(space).then(str("the")).then(space)
+        .then(digit.repeat(4, 4).as("year"))
+        .then(space).then(str("Edition")).then(space)
+        .then(str("of")).then(space).then(str("the")).then(space)
+        .then(ref(rules, "nesc_full_name"))
+        .then(space.then(str("(")).then(str("NESC")).then(ref(rules, "nesc_registered").maybe())
+        .then(str(")")).maybe()));
     rule("nesc_identifier", () => ref(rules, "nesc_draft_nesc")
+        .or(ref(rules, "nesc_preprint_proposal"))
         .or(ref(rules, "nesc_name_first"))
+        .or(ref(rules, "nesc_c2_preprint"))
         .or(ref(rules, "nesc_c2_standard"))
         .or(ref(rules, "nesc_year_first")));
     // --- PSI/SI -------------------------------------------------------------
@@ -556,6 +622,17 @@ function buildRules() {
         .then(ref(rules, "draft").maybe())
         .then(str("(E)").or(str("(F)")).maybe())
         .then(ref(rules, "parenthetical").maybe()));
+    // The generic tail minus the publisher (parg line 154): the publisherled
+    // alternative REQUIRES its publishers, so bare type-word/number forms
+    // route here instead — WITHOUT the redline/book_nickname slots the
+    // publisherled tail carries (the gem rejects "802.3-2012 - Redline").
+    rule("publisherless_ieee", () => (ref(rules, "type_word").as("type").then(space).maybe())
+        .then(ref(rules, "number"))
+        .then(ref(rules, "part_subpart_year").or(ref(rules, "edition")).maybe())
+        .then(ref(rules, "corrigendum").maybe())
+        .then(ref(rules, "draft").maybe())
+        .then(ref(rules, "revision_suffix").maybe())
+        .then(ref(rules, "parenthetical").maybe()));
     rule("corrigendum_identifier", () => (R("publisher").then(R("copublisher").repeat(0, Infinity).as("copublishers")).as("publishers")
         .then(space).maybe()).maybe()
         .then(ref(rules, "type_word").as("type").then(spaceMaybe()).maybe())
@@ -626,12 +703,14 @@ function buildRules() {
         .then(ref(rules, "aiee_identifier").as("aiee")));
     rule("ire_delegation", () => ((match("[1-6]").then(digit).then(space).then(str("IRE"))).or(str("19").then(digit.repeat(2, 2)).then(space).then(str("IRE"))).or(str("IRE").then(space).then(digits.or(str("Standard")).or(str("Std")).or(str("Trans")))).or(str("IEEE-IRE").then(space))).present()
         .then(ref(rules, "ire_identifier").as("ire")));
-    rule("nesc_delegation", () => (str("C2-").then(R("year_digits"))).or(R("year_digits").then(space).then(str("NESC").or(str("National Electrical Safety Code")))).or(str("Draft").then(space).then(str("NESC").or(str("National Electrical Safety Code")))).or(str("National Electrical Safety Code").then(str(",")).then(space).then(str("C2-"))).or(
-    // Catalogue form: "IEEE Std YYYY NESC …" / "IEEE Std YYYY National
-    // Electrical Safety Code" - must not fall through to the generic
-    // standard grammar, which would read YYYY as a number.
-    str("IEEE").then(space).then(str("Std")).then(space).then(R("year_digits")).then(space)
-        .then(str("NESC").or(str("National Electrical Safety Code")))).present()
+    rule("nesc_delegation", () => 
+    // The optional "IEEE Std " prefix is consumed BEFORE the guard: the
+    // catalogue prints NESC documents with it ("IEEE Std C2.2012.Preprint",
+    // "IEEE Std 2017 NESC Handbook"), and a guard anchored at position 0
+    // rejects every prefixed spelling. nesc_year_first carries its own
+    // prefix .maybe(), so the consumed form still parses.
+    str("IEEE").then(space).then(str("Std")).then(space).maybe()
+        .then((str("C2").then(str(".").or(str("-")))).or(R("year_digits").then(space).then(str("NESC").or(str("National Electrical Safety Code")))).or(str("Draft").then(space).then(str("NESC").or(str("National Electrical Safety Code")))).or(str("Preprint")).or(str("National Electrical Safety Code").then(str(",")).then(space).then(str("C2-"))).present())
         .then(ref(rules, "nesc_identifier").as("nesc")));
     rule("identifier", () => ref(rules, "combined_aiee_identifier")
         .or(ref(rules, "aiee_delegation"))
@@ -656,7 +735,7 @@ function buildRules() {
         .or(ref(rules, "ieee_p_identifier"))
         .or(ref(rules, "ansi_p_identifier"))
         .or((R("publisher").then(R("copublisher").repeat(0, Infinity).as("copublishers")).as("publishers")
-        .then(space).maybe()).maybe()
+        .then(space))
         .then(ref(rules, "draft_status").as("draft_status").maybe())
         .then(str("Draft Std").as("type").then(spaceMaybe()).maybe())
         .then(ref(rules, "type_word").as("type")
@@ -688,7 +767,8 @@ function buildRules() {
         .then(ref(rules, "redline").maybe())
         .then(ref(rules, "title_portion").maybe())
         .then(ref(rules, "approved_draft_suffix").maybe()))
-        .or(ref(rules, "no_prefix_ieee")));
+        .or(ref(rules, "no_prefix_ieee"))
+        .or(ref(rules, "publisherless_ieee")));
     return rules;
 }
 export const ieeeGrammar = {