@motionscript/molecule 0.0.0-stage → 0.1.0-alpha.0

package/dist/protein/chemistry.js

@@ -0,0 +1,208 @@
+/**
+ * The chemistry the {@link Protein} node draws from: how big an atom is, what
+ * colour it conventionally takes, what counts as a bond, and which residues are
+ * part of a polymer chain rather than sitting beside it.
+ *
+ * Tables rather than a dependency, for the same reason `graph3d/expression.ts`
+ * is a parser rather than a maths library: this package has to stay loadable in
+ * a bare Node process with no DOM, and what a molecular-graphics library would
+ * bring with it — a renderer, a fetch layer, a DOM — is everything the scene
+ * builder was split apart to avoid.
+ *
+ * The numbers are the standard ones. Van der Waals radii are Bondi's, covalent
+ * radii are Cordero's, and the colours are the CPK scheme every molecular viewer
+ * has used since Corey and Pauling built theirs out of painted wood — which is
+ * the point of using them: a biologist reads oxygen as red before they have
+ * read the legend.
+ */
+/** Ångströms. What an atom's electron cloud actually occupies. */
+const VAN_DER_WAALS = {
+    H: 1.1,
+    C: 1.7,
+    N: 1.55,
+    O: 1.52,
+    F: 1.47,
+    NA: 2.27,
+    MG: 1.73,
+    P: 1.8,
+    S: 1.8,
+    CL: 1.75,
+    K: 2.75,
+    CA: 2.31,
+    MN: 2.05,
+    FE: 2.04,
+    CO: 2.0,
+    NI: 1.97,
+    CU: 1.96,
+    ZN: 2.01,
+    SE: 1.9,
+    BR: 1.85,
+    I: 1.98,
+};
+/** The fallback radius, carbon's — the element most of a protein is made of. */
+const DEFAULT_VAN_DER_WAALS = 1.7;
+/** Ångströms. Half of how far two of these sit apart when bonded. */
+const COVALENT = {
+    H: 0.31,
+    C: 0.76,
+    N: 0.71,
+    O: 0.66,
+    F: 0.57,
+    NA: 1.66,
+    MG: 1.41,
+    P: 1.07,
+    S: 1.05,
+    CL: 1.02,
+    K: 2.03,
+    CA: 1.76,
+    MN: 1.39,
+    FE: 1.32,
+    CO: 1.26,
+    NI: 1.24,
+    CU: 1.32,
+    ZN: 1.22,
+    SE: 1.2,
+    BR: 1.2,
+    I: 1.39,
+};
+const DEFAULT_COVALENT = 0.77;
+/**
+ * The CPK colours, as Jmol renders them.
+ *
+ * Only the elements a biological structure actually contains, plus the metals
+ * that turn up in cofactors. Anything else takes {@link UNKNOWN_ELEMENT_COLOR},
+ * which is deliberately garish — an unrecognised element should look like a
+ * question rather than blend into the carbons.
+ */
+const CPK = {
+    H: "#ffffff",
+    C: "#909090",
+    N: "#3050f8",
+    O: "#ff0d0d",
+    F: "#90e050",
+    NA: "#ab5cf2",
+    MG: "#8aff00",
+    P: "#ff8000",
+    S: "#ffff30",
+    CL: "#1ff01f",
+    K: "#8f40d4",
+    CA: "#3dff00",
+    MN: "#9c7ac7",
+    FE: "#e06633",
+    CO: "#f090a0",
+    NI: "#50d050",
+    CU: "#c88033",
+    ZN: "#7d80b0",
+    SE: "#ffa100",
+    BR: "#a62929",
+    I: "#940094",
+};
+/** What an element nobody has a colour for is drawn in. */
+export const UNKNOWN_ELEMENT_COLOR = "#ff1493";
+/** An element's van der Waals radius in Ångströms. */
+export function vanDerWaalsRadius(element) {
+    return VAN_DER_WAALS[element] ?? DEFAULT_VAN_DER_WAALS;
+}
+/** An element's covalent radius in Ångströms — half of a bond it makes. */
+export function covalentRadius(element) {
+    return COVALENT[element] ?? DEFAULT_COVALENT;
+}
+/** The CPK colour for an element, as a `#rrggbb` string. */
+export function elementColor(element) {
+    return CPK[element] ?? UNKNOWN_ELEMENT_COLOR;
+}
+/**
+ * The standard amino acids, plus the two modified residues common enough that
+ * treating them as foreign would put a hole in the middle of a chain:
+ * selenomethionine (`MSE`, how a crystallographer phases a new structure) and
+ * pyroglutamate (`PCA`).
+ *
+ * Both arrive as `HETATM` records, which is exactly why the set is consulted
+ * rather than the record type — "is this part of the chain" is a question about
+ * the residue, and the file answers a different one.
+ */
+const AMINO_ACIDS = new Set([
+    "ALA", "ARG", "ASN", "ASP", "CYS", "GLN", "GLU", "GLY", "HIS", "ILE",
+    "LEU", "LYS", "MET", "PHE", "PRO", "SER", "THR", "TRP", "TYR", "VAL",
+    "MSE", "PCA", "SEC", "PYL",
+]);
+/** The nucleotides, RNA and DNA. */
+const NUCLEOTIDES = new Set([
+    "A", "C", "G", "U", "I",
+    "DA", "DC", "DG", "DT", "DI",
+]);
+/**
+ * The waters. Named separately from the rest of the hetero atoms because they
+ * are the one kind a viewer hides by default: a crystal structure carries
+ * hundreds of them, they are chemically uninteresting to the picture being
+ * drawn, and left on they bury the molecule in red dots.
+ */
+const WATERS = new Set(["HOH", "DOD", "WAT", "H2O", "TIP"]);
+/** Classifies a residue by its three-letter code. */
+export function residueKind(name) {
+    const code = name.trim().toUpperCase();
+    if (AMINO_ACIDS.has(code))
+        return "amino";
+    if (NUCLEOTIDES.has(code))
+        return "nucleic";
+    if (WATERS.has(code))
+        return "water";
+    return "other";
+}
+/**
+ * The atom a residue's backbone trace passes through: the α-carbon of an amino
+ * acid, the phosphorus of a nucleotide.
+ *
+ * One atom per residue rather than the whole backbone, because what the trace is
+ * *for* is the smooth curve a ribbon is swept along, and the N–CA–C zig-zag
+ * would put a kink at every residue. Every molecular viewer traces α-carbons for
+ * the same reason.
+ */
+export function traceAtomName(kind) {
+    if (kind === "amino")
+        return "CA";
+    if (kind === "nucleic")
+        return "P";
+    return null;
+}
+/**
+ * The element an atom belongs to, from the file's element column when it has
+ * one and from the atom's *name* when it doesn't.
+ *
+ * The fallback matters more than it looks: the element column is right-justified
+ * in columns 77–78 of a PDB record and plenty of older files, and most files
+ * written by hand, simply stop before it. The name is then all there is, and
+ * reading it is not quite trimming the digits off — an amino acid's `CA` is a
+ * carbon and an ion's `CA` is calcium, and the two are told apart only by what
+ * residue they sit in. Hence {@link kind}.
+ */
+export function elementOf(declared, atomName, kind) {
+    const stated = declared.trim().toUpperCase();
+    if (stated !== "")
+        return stated;
+    // PDB atom names are padded so that the element starts in column 14 for a
+    // two-letter element and column 15 for a one-letter one — but only in files
+    // that respect the alignment, which is why this reads the characters instead:
+    // strip the leading digit an alternate hydrogen carries (`1HB`), then take the
+    // letters.
+    const name = atomName.trim().toUpperCase().replace(/^\d+/, "");
+    const letters = name.replace(/[^A-Z]/g, "");
+    if (letters === "")
+        return "";
+    // Inside a polymer residue the only two-letter elements are the ones that
+    // can't be confused: everything else is C, N, O, S or P followed by the
+    // position letters that name the atom (`CB`, `NZ`, `OG1`). A `CA` there is the
+    // α-carbon, never calcium.
+    if (kind === "amino" || kind === "nucleic") {
+        if (letters.startsWith("SE"))
+            return "SE";
+        return letters.slice(0, 1);
+    }
+    // Outside one — a ligand, an ion, a cofactor — a two-letter element is real,
+    // so prefer the longest match the tables know before falling back to one.
+    const pair = letters.slice(0, 2);
+    if (pair in COVALENT)
+        return pair;
+    return letters.slice(0, 1);
+}
+//# sourceMappingURL=chemistry.js.map

package/dist/protein/chemistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chemistry.js","sourceRoot":"","sources":["../../src/protein/chemistry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The chemistry the {@link Protein} node draws from: how big an atom is, what\n * colour it conventionally takes, what counts as a bond, and which residues are\n * part of a polymer chain rather than sitting beside it.\n *\n * Tables rather than a dependency, for the same reason `graph3d/expression.ts`\n * is a parser rather than a maths library: this package has to stay loadable in\n * a bare Node process with no DOM, and what a molecular-graphics library would\n * bring with it — a renderer, a fetch layer, a DOM — is everything the scene\n * builder was split apart to avoid.\n *\n * The numbers are the standard ones. Van der Waals radii are Bondi's, covalent\n * radii are Cordero's, and the colours are the CPK scheme every molecular viewer\n * has used since Corey and Pauling built theirs out of painted wood — which is\n * the point of using them: a biologist reads oxygen as red before they have\n * read the legend.\n */\n\n/** Ångströms. What an atom's electron cloud actually occupies. */\nconst VAN_DER_WAALS: Readonly<Record<string, number>> = {\n  H: 1.1,\n  C: 1.7,\n  N: 1.55,\n  O: 1.52,\n  F: 1.47,\n  NA: 2.27,\n  MG: 1.73,\n  P: 1.8,\n  S: 1.8,\n  CL: 1.75,\n  K: 2.75,\n  CA: 2.31,\n  MN: 2.05,\n  FE: 2.04,\n  CO: 2.0,\n  NI: 1.97,\n  CU: 1.96,\n  ZN: 2.01,\n  SE: 1.9,\n  BR: 1.85,\n  I: 1.98,\n}\n\n/** The fallback radius, carbon's — the element most of a protein is made of. */\nconst DEFAULT_VAN_DER_WAALS = 1.7\n\n/** Ångströms. Half of how far two of these sit apart when bonded. */\nconst COVALENT: Readonly<Record<string, number>> = {\n  H: 0.31,\n  C: 0.76,\n  N: 0.71,\n  O: 0.66,\n  F: 0.57,\n  NA: 1.66,\n  MG: 1.41,\n  P: 1.07,\n  S: 1.05,\n  CL: 1.02,\n  K: 2.03,\n  CA: 1.76,\n  MN: 1.39,\n  FE: 1.32,\n  CO: 1.26,\n  NI: 1.24,\n  CU: 1.32,\n  ZN: 1.22,\n  SE: 1.2,\n  BR: 1.2,\n  I: 1.39,\n}\n\nconst DEFAULT_COVALENT = 0.77\n\n/**\n * The CPK colours, as Jmol renders them.\n *\n * Only the elements a biological structure actually contains, plus the metals\n * that turn up in cofactors. Anything else takes {@link UNKNOWN_ELEMENT_COLOR},\n * which is deliberately garish — an unrecognised element should look like a\n * question rather than blend into the carbons.\n */\nconst CPK: Readonly<Record<string, string>> = {\n  H: \"#ffffff\",\n  C: \"#909090\",\n  N: \"#3050f8\",\n  O: \"#ff0d0d\",\n  F: \"#90e050\",\n  NA: \"#ab5cf2\",\n  MG: \"#8aff00\",\n  P: \"#ff8000\",\n  S: \"#ffff30\",\n  CL: \"#1ff01f\",\n  K: \"#8f40d4\",\n  CA: \"#3dff00\",\n  MN: \"#9c7ac7\",\n  FE: \"#e06633\",\n  CO: \"#f090a0\",\n  NI: \"#50d050\",\n  CU: \"#c88033\",\n  ZN: \"#7d80b0\",\n  SE: \"#ffa100\",\n  BR: \"#a62929\",\n  I: \"#940094\",\n}\n\n/** What an element nobody has a colour for is drawn in. */\nexport const UNKNOWN_ELEMENT_COLOR = \"#ff1493\"\n\n/** An element's van der Waals radius in Ångströms. */\nexport function vanDerWaalsRadius(element: string): number {\n  return VAN_DER_WAALS[element] ?? DEFAULT_VAN_DER_WAALS\n}\n\n/** An element's covalent radius in Ångströms — half of a bond it makes. */\nexport function covalentRadius(element: string): number {\n  return COVALENT[element] ?? DEFAULT_COVALENT\n}\n\n/** The CPK colour for an element, as a `#rrggbb` string. */\nexport function elementColor(element: string): string {\n  return CPK[element] ?? UNKNOWN_ELEMENT_COLOR\n}\n\n/**\n * The standard amino acids, plus the two modified residues common enough that\n * treating them as foreign would put a hole in the middle of a chain:\n * selenomethionine (`MSE`, how a crystallographer phases a new structure) and\n * pyroglutamate (`PCA`).\n *\n * Both arrive as `HETATM` records, which is exactly why the set is consulted\n * rather than the record type — \"is this part of the chain\" is a question about\n * the residue, and the file answers a different one.\n */\nconst AMINO_ACIDS = new Set([\n  \"ALA\", \"ARG\", \"ASN\", \"ASP\", \"CYS\", \"GLN\", \"GLU\", \"GLY\", \"HIS\", \"ILE\",\n  \"LEU\", \"LYS\", \"MET\", \"PHE\", \"PRO\", \"SER\", \"THR\", \"TRP\", \"TYR\", \"VAL\",\n  \"MSE\", \"PCA\", \"SEC\", \"PYL\",\n])\n\n/** The nucleotides, RNA and DNA. */\nconst NUCLEOTIDES = new Set([\n  \"A\", \"C\", \"G\", \"U\", \"I\",\n  \"DA\", \"DC\", \"DG\", \"DT\", \"DI\",\n])\n\n/**\n * The waters. Named separately from the rest of the hetero atoms because they\n * are the one kind a viewer hides by default: a crystal structure carries\n * hundreds of them, they are chemically uninteresting to the picture being\n * drawn, and left on they bury the molecule in red dots.\n */\nconst WATERS = new Set([\"HOH\", \"DOD\", \"WAT\", \"H2O\", \"TIP\"])\n\n/** What a residue is, which decides whether it joins a backbone trace. */\nexport type ResidueKind = \"amino\" | \"nucleic\" | \"water\" | \"other\"\n\n/** Classifies a residue by its three-letter code. */\nexport function residueKind(name: string): ResidueKind {\n  const code = name.trim().toUpperCase()\n  if (AMINO_ACIDS.has(code)) return \"amino\"\n  if (NUCLEOTIDES.has(code)) return \"nucleic\"\n  if (WATERS.has(code)) return \"water\"\n  return \"other\"\n}\n\n/**\n * The atom a residue's backbone trace passes through: the α-carbon of an amino\n * acid, the phosphorus of a nucleotide.\n *\n * One atom per residue rather than the whole backbone, because what the trace is\n * *for* is the smooth curve a ribbon is swept along, and the N–CA–C zig-zag\n * would put a kink at every residue. Every molecular viewer traces α-carbons for\n * the same reason.\n */\nexport function traceAtomName(kind: ResidueKind): string | null {\n  if (kind === \"amino\") return \"CA\"\n  if (kind === \"nucleic\") return \"P\"\n  return null\n}\n\n/**\n * The element an atom belongs to, from the file's element column when it has\n * one and from the atom's *name* when it doesn't.\n *\n * The fallback matters more than it looks: the element column is right-justified\n * in columns 77–78 of a PDB record and plenty of older files, and most files\n * written by hand, simply stop before it. The name is then all there is, and\n * reading it is not quite trimming the digits off — an amino acid's `CA` is a\n * carbon and an ion's `CA` is calcium, and the two are told apart only by what\n * residue they sit in. Hence {@link kind}.\n */\nexport function elementOf(\n  declared: string,\n  atomName: string,\n  kind: ResidueKind\n): string {\n  const stated = declared.trim().toUpperCase()\n  if (stated !== \"\") return stated\n\n  // PDB atom names are padded so that the element starts in column 14 for a\n  // two-letter element and column 15 for a one-letter one — but only in files\n  // that respect the alignment, which is why this reads the characters instead:\n  // strip the leading digit an alternate hydrogen carries (`1HB`), then take the\n  // letters.\n  const name = atomName.trim().toUpperCase().replace(/^\\d+/, \"\")\n  const letters = name.replace(/[^A-Z]/g, \"\")\n  if (letters === \"\") return \"\"\n\n  // Inside a polymer residue the only two-letter elements are the ones that\n  // can't be confused: everything else is C, N, O, S or P followed by the\n  // position letters that name the atom (`CB`, `NZ`, `OG1`). A `CA` there is the\n  // α-carbon, never calcium.\n  if (kind === \"amino\" || kind === \"nucleic\") {\n    if (letters.startsWith(\"SE\")) return \"SE\"\n    return letters.slice(0, 1)\n  }\n\n  // Outside one — a ligand, an ion, a cofactor — a two-letter element is real,\n  // so prefer the longest match the tables know before falling back to one.\n  const pair = letters.slice(0, 2)\n  if (pair in COVALENT) return pair\n  return letters.slice(0, 1)\n}\n"]}

package/dist/protein/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The Protein node — a **native** node type (see `node-types.ts` /
+ * `NODE_CLASS_BY_KEY`) like the chart family and the 3D graph beside it: built,
+ * themed and animated from the inspector rather than loaded as a code package.
+ *
+ * It draws a molecular structure — a protein, a nucleic acid, a complex of both
+ * with whatever is bound to them — in one of four representations, from a
+ * coordinate file the Protein Data Bank publishes.
+ *
+ * Three things about it are worth knowing before reading the parts:
+ *
+ * **The file is parsed outside the render.** `buildScene` is synchronous and a
+ * coordinate file arrives over a network, so the fetch and the parse happen
+ * ahead of the build and what reaches the node is a finished
+ * {@link ProteinStructure} — the same arrangement a chart has with its rows.
+ * That is why `parse.ts` is exported: the app's structure store is its caller,
+ * not this node.
+ *
+ * **The chemistry is a table, not a dependency.** Radii, colours and what counts
+ * as a bond live in `chemistry.ts` for the same reason `graph3d/expression.ts`
+ * is a parser rather than a maths library: this package has to stay loadable in
+ * a bare Node process, and a molecular-graphics library brings a renderer, a
+ * fetch layer and a DOM with it.
+ *
+ * **There is no pointer.** The camera is three tweenable numbers rather than a
+ * drag, because the studio renders a timeline and every frame has to be
+ * reproducible under scrubbing and export. See {@link Protein}.
+ */
+export * from "./chemistry.js";
+export * from "./parse.js";
+export * from "./protein.js";
+export * from "./ribbon.js";
+export * from "./shared.js";
+export * from "./structure.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/protein/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/protein/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC"}

package/dist/protein/index.js

@@ -0,0 +1,35 @@
+/**
+ * The Protein node — a **native** node type (see `node-types.ts` /
+ * `NODE_CLASS_BY_KEY`) like the chart family and the 3D graph beside it: built,
+ * themed and animated from the inspector rather than loaded as a code package.
+ *
+ * It draws a molecular structure — a protein, a nucleic acid, a complex of both
+ * with whatever is bound to them — in one of four representations, from a
+ * coordinate file the Protein Data Bank publishes.
+ *
+ * Three things about it are worth knowing before reading the parts:
+ *
+ * **The file is parsed outside the render.** `buildScene` is synchronous and a
+ * coordinate file arrives over a network, so the fetch and the parse happen
+ * ahead of the build and what reaches the node is a finished
+ * {@link ProteinStructure} — the same arrangement a chart has with its rows.
+ * That is why `parse.ts` is exported: the app's structure store is its caller,
+ * not this node.
+ *
+ * **The chemistry is a table, not a dependency.** Radii, colours and what counts
+ * as a bond live in `chemistry.ts` for the same reason `graph3d/expression.ts`
+ * is a parser rather than a maths library: this package has to stay loadable in
+ * a bare Node process, and a molecular-graphics library brings a renderer, a
+ * fetch layer and a DOM with it.
+ *
+ * **There is no pointer.** The camera is three tweenable numbers rather than a
+ * drag, because the studio renders a timeline and every frame has to be
+ * reproducible under scrubbing and export. See {@link Protein}.
+ */
+export * from "./chemistry.js";
+export * from "./parse.js";
+export * from "./protein.js";
+export * from "./ribbon.js";
+export * from "./shared.js";
+export * from "./structure.js";
+//# sourceMappingURL=index.js.map

package/dist/protein/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/protein/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC","sourcesContent":["/**\n * The Protein node — a **native** node type (see `node-types.ts` /\n * `NODE_CLASS_BY_KEY`) like the chart family and the 3D graph beside it: built,\n * themed and animated from the inspector rather than loaded as a code package.\n *\n * It draws a molecular structure — a protein, a nucleic acid, a complex of both\n * with whatever is bound to them — in one of four representations, from a\n * coordinate file the Protein Data Bank publishes.\n *\n * Three things about it are worth knowing before reading the parts:\n *\n * **The file is parsed outside the render.** `buildScene` is synchronous and a\n * coordinate file arrives over a network, so the fetch and the parse happen\n * ahead of the build and what reaches the node is a finished\n * {@link ProteinStructure} — the same arrangement a chart has with its rows.\n * That is why `parse.ts` is exported: the app's structure store is its caller,\n * not this node.\n *\n * **The chemistry is a table, not a dependency.** Radii, colours and what counts\n * as a bond live in `chemistry.ts` for the same reason `graph3d/expression.ts`\n * is a parser rather than a maths library: this package has to stay loadable in\n * a bare Node process, and a molecular-graphics library brings a renderer, a\n * fetch layer and a DOM with it.\n *\n * **There is no pointer.** The camera is three tweenable numbers rather than a\n * drag, because the studio renders a timeline and every frame has to be\n * reproducible under scrubbing and export. See {@link Protein}.\n */\nexport * from \"./chemistry\";\nexport * from \"./parse\";\nexport * from \"./protein\";\nexport * from \"./ribbon\";\nexport * from \"./shared\";\nexport * from \"./structure\";\n"]}

package/dist/protein/parse.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Reads a coordinate file into a {@link ProteinStructure}.
+ *
+ * Two formats, because the Protein Data Bank serves two and which one an entry
+ * has is not the author's choice: the legacy **PDB** format numbers atoms in
+ * five columns and names chains in one, so an entry that outgrew either — a
+ * ribosome, a capsid — exists only as **mmCIF**. Refusing the second would mean
+ * refusing exactly the structures most worth looking at.
+ *
+ * Both are read the same way: pull out an atom list and whatever secondary
+ * structure the file annotates, then hand both to `deriveStructure`, which does
+ * the geometry. {@link parseStructure} sniffs which is which, so a caller
+ * holding a downloaded file never has to.
+ *
+ * **The first model only.** An NMR ensemble is twenty superposed conformations
+ * of the same molecule; drawing all of them at once produces a blur, and
+ * choosing between them is a question this node does not ask. The first is the
+ * conventional representative.
+ */
+import { type ProteinStructure } from "./structure.js";
+/**
+ * Reads a coordinate file, detecting its format from the contents.
+ *
+ * `id` labels the result — an accession, or the asset's name. Anything that
+ * can't be read at all comes back as {@link EMPTY_STRUCTURE} rather than
+ * throwing: this runs against a file someone just uploaded or an accession
+ * someone is halfway through typing, and both of those are ordinary states
+ * rather than errors. An empty structure draws nothing, which is the honest
+ * picture of a file with no atoms in it.
+ */
+export declare function parseStructure(text: string, id?: string): ProteinStructure;
+//# sourceMappingURL=parse.d.ts.map

package/dist/protein/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/protein/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAIL,KAAK,gBAAgB,EAEtB,MAAM,aAAa,CAAA;AAEpB;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,SAAK,GAAG,gBAAgB,CAKtE"}